rustc: Implement the #[managed] attribute and add an intrinsic
to detect this.

Renames owns_managed -> owns_at_managed, and adds owns_new_managed.
std::gc: add a true garbage collector and use it for  `Gc<T>`.

The garbage collector is a naive mark-and-sweep collector that is
conservative on the stack and mostly conservative on the heap.

This currently will not scan through ~, @, ~[] or @[], nor in any of the
global or task/thread local storages. Hence, `Gc<T>` placed in the wrong
spot may be deallocated while still live, and so all borrowing methods
are marked unsafe. (And `Gc<T>` is marked `#[experimental]`.)
std::gc: support running destructors on values in Gc<T>.
std::gc: add root registration functions, using type information to
shortcircuit when possible.

In theory, this design (using `owns_new_managed` to detect when a type
contains `Gc<T>`) means a smart pointer/alternate vector can just
unconditionally call `register_changes_root` and not worry about whether
this is actually necessary (that is, whether the memory regions actually
needs to be scanned for pointers) because those two functions do it
themselves.
Add the library defined vector type from rust-core.
std::libvec: make it GC safe.
std: add Uniq<T>, a GC-safe version of ~.
std::gc: cache small(ish) allocations to avoid thrashing the pointer
trie.

Allocations are rounded to the next power of two and cached when they
become unreachable. Except for those above 1 MB.
std::gc: flip an external reachability bit instead of the reachability
of every pointer individually.

This makes collections 15% faster.
std::gc: allow finalisers to touch the GC (in a restricted way).

This allows Gc<Vec<Gc<T>>> to work by allow it to register changes to
the GC roots. An unsafe pointer to the GC is stored in the borrowed
version, so any users should be careful they understand the
implementation details of the GC before calling anything on that GC via
that pointer.
rustc: convert owns_new_managed to reaches_new_managed.

When we're tracing, we don't just care about what's stored unboxed in a
value, but whether we can possibly get to a #[managed] value via
pointers.
std::gc: convert to a tracing garbage collector.

For the moment, this is designed around a non-special trait `Trace`,
which allows values to precisely inform the GC of their contained Gc<T>
pointers.

Unfortunately, the fact that the trait is just like any other means that
generic data structures require a `Trace` bound on their generics
always, to be able to register themselves with the GC, even for
substitutions of the parameters that don't contain any Gc<T> types at
all.
std::gc: search task-local storage for garbage collected values.

Storing a Gc<T> in local data is now safe.
std::gc: avoid putting all unreachable points into a vector.
std::gc: use a inverse-load-factor based collection policy.

This makes garbage collections proportionally less frequent as the live
heap gets larger. Each collection takes time proportional to the size of
the heap, so doing a collection regularly (i.e. O(heap size)
collections) gives O(heap size^2) behaviour. Doing the collections less
frequently lets us keep O(heap size) performance.
std::gc: remove a branch from `compute_log_rounded_up_size`.