Cpp11 transition

Proposed changes

Notes in italics might not be available on MSVC.

1. enums: Replace all enums with enum classes, getting rid of the special "type" namespace.
2. Rewrite math classes (vector, dim, matrix) using variadic templates
3. Rewrite signals using variadic templates and perfect forwarding
4. Remove unique_ptr
5. Replace fcppt::container::array with std::array (mizuiro needs the fusion adaptation and std::array isn't adapted)
6. Remove fcppt::ref and fcppt::cref
7. Replace std::tr1::bind with std::bind
8. Replace std::tr1::unordered_ with std::unordered
9. Keep using boost.chrono for now because std.chrono is broken in VC++: steady_clock generates time_points of the wrong type
10. Replace boost.thread with std.thread
11. Replace boost.random with std.random (in fcppt::random, for example).
12. Replace boost.type_traits with std.type_traits (boost.mpl's integer comparison structs (like equal_to) have trouble with std type traits)
13. Rewrite noncopyable and nonassignable with delete specifications (doesn't work in VC++)
14. Replace fcppt.static_assert by static_assert
15. We need to keep fcppt.assign to initialize containers with movable types (Furthermore, VC++'s stdlib doesn't support initializer lists, but they can at least be used with arrays)
16. Use template typedefs for static math types like fcppt.math.vector.static (doesn't work in VC++)
17. Use the Unicode conversions in the standard in sge.charconv
18. Replace boost/next_prior by the stdlib functions.
19. Replace for(foo::iterator it = ...) loops by range based for
20. Remove (and replace) fcppt::function::object
21. Remove fcppt::alignment in favour of alignas/alignof (only works in gcc-4.8 and maybe clang)
22. Replace ptr containers of types T that are noncopyable by normal containers of movable types, if T is not polymorphic
23. Replace shared_ptrs where we can move unique_ptrs
24. Remove SAFE_BOOL in favour of explicit operator bool
25. Use lambdas where appropriate, especially to replace extra function objects in detail or anonymous namespaces, or phoenix expressions