Make some more rt components public

Primarily this makes the Scheduler and all of its related interfaces public. The
reason for doing this is that currently any extern event loops had no access to
the scheduler at all. This allows third-party event loops to manipulate the
scheduler, along with allowing the uv event loop to live inside of its own
crate.
Register new snapshots
Capitalize statics in f32 and f64 mods

Fixes #10077
std: Move the SendDeferred trait to std::comm
rt::task: Make current_stack_segment public again

This was done in 2145de8c and reverted in 0ada7c7f, but Servo needs it.

Closes #10065.
Field identifiers now include specific spans (Closes #8263).
#8263 part 2: Adding struct name.
rewrite shootout-binarytrees.rs to match shootout directives

The old version didn't follow shootout's directives: no memory were
deallocated.  At the same time, parallelisation of the computation.

fix #2913
auto merge of #10135 : alexcrichton/rust/snapshots, r=thestinger

Plus some migration from `let mut this = self` to `mut self` (yay!)
Update prelude items in Vim syntax file.
Fix Vim indent for wrapped function arguments.
auto merge of #10141 : kmcallister/rust/current_stack_segment, r=alexcrichton

This was done in 2145de8c and reverted in 0ada7c7f, but Servo needs it.

Closes #10065.

r? @brson
auto merge of #10142 : pythonesque/rust/issue-8263, r=catamorphism

This is, I think, the minimal change required.  I would have included a test but as far as I can tell there is currently no way to precisely test that the span for an error underlines the correct word.  I did verify it manually.
Move rust's uv implementation to its own crate

There are a few reasons that this is a desirable move to take:

1. Proof of concept that a third party event loop is possible
2. Clear separation of responsibility between rt::io and the uv-backend
3. Enforce in the future that the event loop is "pluggable" and replacable

Here's a quick summary of the points of this pull request which make this
possible:

* Two new lang items were introduced: event_loop, and event_loop_factory.
  The idea of a "factory" is to define a function which can be called with no
  arguments and will return the new event loop as a trait object. This factory
  is emitted to the crate map when building an executable. The factory doesn't
  have to exist, and when it doesn't then an empty slot is in the crate map and
  a basic event loop with no I/O support is provided to the runtime.

* When building an executable, then the rustuv crate will be linked by default
  (providing a default implementation of the event loop) via a similar method to
  injecting a dependency on libstd. This is currently the only location where
  the rustuv crate is ever linked.

* There is a new #[no_uv] attribute (implied by #[no_std]) which denies
  implicitly linking to rustuv by default

Closes #5019
Replaced empty destructors with NonCopyable #7427
closes #7427
Added the comment #7427
Changed name to non_copyable #7427
updated the places where the struct is created #7427
Indentation
removed extra line