Implement clone() for TCP/UDP/Unix sockets

This is part of the overall strategy I would like to take when approaching
issue #11165. The only two I/O objects that reasonably want to be "split" are
the network stream objects. Everything else can be "split" by just creating
another version.

The initial idea I had was the literally split the object into a reader and a
writer half, but that would just introduce lots of clutter with extra interfaces
that were a little unnnecssary, or it would return a ~Reader and a ~Writer which
means you couldn't access things like the remote peer name or local socket name.

The solution I found to be nicer was to just clone the stream itself. The clone
is just a clone of the handle, nothing fancy going on at the kernel level.
Conceptually I found this very easy to wrap my head around (everything else
supports clone()), and it solved the "split" problem at the same time.

The cloning support is pretty specific per platform/lib combination:

* native/win32 - uses some specific WSA apis to clone the SOCKET handle
* native/unix - uses dup() to get another file descriptor
* green/all - This is where things get interesting. When we support full clones
              of a handle, this implies that we're allowing simultaneous writes
              and reads to happen. It turns out that libuv doesn't support two
              simultaneous reads or writes of the same object. It does support
              *one* read and *one* write at the same time, however. Some extra
              infrastructure was added to just block concurrent writers/readers
              until the previous read/write operation was completed.

I've added tests to the tcp/unix modules to make sure that this functionality is
supported everywhere.
rustc: Add the __tt_map_insert and __tt_map_get_expr macros

Behind the `__tt_map` feature gate. This feature name starts with
a double underscore to emphasize it's a hack, but there's no
precedent for naming features this way.
rustc: Introduce a new diagnostic code registry

This provides a way to create stable diagnostic codes, while keeping
the overal burden on compiler writers low, and introducing a way to
incrementally provide extended documentation of diagnostics.
Introduce more diagnostic infrastructure
Convert to new diagnostics

This pairs almost every error in libsyntax and librustc with an error code,
emitting with the macros:

* alert_fatal!(cx, code, fmt, args);
* alert_err!(cx, code, fmt, args);
* alert_warn!(cx, code, fmt, args);
* span_fatal!(cx, span, code, fmt, args);
* span_err!(cx, span, code, fmt, args);
* span_warn!(cx, span, code, fmt, args);
* resolve_err!(cx, span, code, fmt, args);

These macros call the methods 'fatal_without_diagnostic_code' etc. on any
given context. For the most part the old diagnostic methods on the various
sessions and handles and contexts have been renamed in a way that is
obnoxious to call (use the macros), but the macro ExtCtxt still contains
the simple `fatal` methods, etc. for ease of use by out of tree procedural
macros.

Lint errors are difficult to convert to this system because they don't use
string literals for reporting errors, so they don't have their own codes yet.
rustc: Add UI for extended diagnostics

When diagnostics with codes are emitted they appear in magenta brackets,
like `[A0002]`. After failure a note is emitted indicating whether
any errors had extended documentation and suggesting the `--explain help`
flag.