core: Inherit the container module
core: Inherit the char module
core: Inherit the finally module
core: Inherit the any module
core: Inherit the raw module
core: Inherit the default module
core: Inherit the unit module
core: Inherit the clone module
core: Bring clone tests up to date in style
core: Inherit the tuple module
core: Inherit the bool module
core: Inherit the option module
core: Inherit the iter module
core: Inherit the cmp module

This removes the TotalOrd and TotalEq implementation macros, they will be added
later to the numeric modules (where the other comparison implementations live).
core: Inhert ~/@/& cmp traits, remove old modules

This commit removes the std::{managed, reference} modules. The modules serve
essentially no purpose, and the only free function removed was `managed::ptr_eq`
which can be achieved by comparing references.

[breaking-change]
core: Inherit what's possible from the num module

This strips out all string-related functionality from the num module. The
inherited functionality is all that will be implemented in libcore (for now).
Primarily, libcore will not implement the Float trait or any string-related
functionality.

It may be possible to migrate string parsing functionality into libcore in the
future, but for now it will remain in libstd.

All functionality in core::num is reexported in std::num.
core: Inherit the specific numeric modules

This implements all traits inside of core::num for all the primitive types,
removing all the functionality from libstd. The std modules reexport all of the
necessary items from the core modules.
core: Inherit non-allocating slice functionality

This commit adds a new trait, MutableVectorAllocating, which represents
functions on vectors which can allocate.

This is another extension trait to slices which should be removed once a lang
item exists for the ~ allocation.
core: Inherit necessary unicode functionality

The unicode module remains private, but the normalization iterators require an
allocation, so some functionality needs to remain in libstd
core: Inherit possible string functionality

This moves as much allocation as possible from teh std::str module into
core::str. This includes essentially all non-allocating functionality, mostly
iterators and slicing and such.

This primarily splits the Str trait into only having the as_slice() method,
adding a new StrAllocating trait to std::str which contains the relevant new
allocation methods. This is a breaking change if any of the methods of "trait
Str" were overriden. The old functionality can be restored by implementing both
the Str and StrAllocating traits.

[breaking-change]