Add a variant of home_for_io that consumes the handle. Refactor out common parts of the home_for_io variants.
Split out starting a listener from accepting incoming connections.

The Listener trait takes two type parameters, the type of connection and the type of Acceptor,
and specifies only one method, listen, which consumes the listener and produces an Acceptor.

The Acceptor trait takes one type parameter, the type of connection, and defines two methods.
The accept() method waits for an incoming connection attempt and returns the result.
The incoming() method creates an iterator over incoming connections and is a default method.

Example:

let listener = TcpListener.bind(addr); // Bind to a socket
let acceptor = listener.listen(); // Start the listener
for stream in acceptor.incoming() {
    // Process incoming connections forever (or until you break out of the loop)
}
std::iterator: Introduce trait ExactSizeHint

The trait `ExactSizeHint` is introduced to solve a few small niggles:

* We can't reverse (`.invert()`) an enumeration iterator
* for a vector, we have `v.iter().position(f)` but `v.rposition(f)`.
* We can't reverse `Zip` even if both iterators are from vectors

`ExactSizeHint` is an empty trait that is intended to indicate that an
iterator, for example `VecIterator`, knows its exact finite size and
reports it correctly using `.size_hint()`. Only adaptors that preserve
this at all times, can expose this trait further. (Where here we say
finite for fitting in uint).
std::iterator: Implement .next_back() for Zip

Let Zip be double-ended when both its children have the ExactSizeHint
trait.
std::iterator: Add tests for .next_back() on Zip and Enumerate
std: Implement .rposition() on double-ended iterators with known size

This is a generalization of the vector .rposition() method, to all
double-ended iterators that have the ExactSizeHint trait.

This resolves the slight asymmetry around `position` and `rposition`

* position from front is `vec.iter().position()`
* position from the back was, `vec.rposition()` is now `vec.iter().rposition()`

Additionally, other indexed sequences (only `extra::ringbuf` I think),
will have the same method available once it implements ExactSizeHint.
std::str: Use reverse enumerate and .rposition

Simplify code by using the reversibility of enumerate and use
.rposition().
std::select: Use correct indices from the front

Caught a bug where .enumerate() was used on a reverse iterator. The
indices should be counted from the front here (bblum confirms).
std::iterator: Add back .rposition() test
std::iterator: Use ExactSize, inheriting DoubleEndedIterator

Address discussion with acrichto; inherit DoubleEndedIterator so that
`.rposition()` can be a default method, and that the nische of the trait
is clear. Use assertions when using `.size_hint()` in reverse enumerate
and `.rposition()`
std/extra: Add ExactSize for Bitv, DList, RingBuf, Option iterators
rt::io: Add Bytes iterator for Reader

An iterator that simply calls `.read_bytes()` each iteration.

I think choosing to own the Reader value and implementing Decorator to
allow extracting it is the most generically useful. The Reader type
variable can of course be some kind of reference type that implements
Reader.
Fix #8898
turn off android ndk asm pass
repr: print functions as `fn()`
auto merge of #8928 : novalis/rust/fix-8898, r=thestinger

I think this fixes 8898.  I'm a bit unsure about how slices and owned pointers to vectors-of-unit already worked, but since they were already working, I didn't mess with them.
repr: add support for trait objects

Closes #8916
auto merge of #8931 : ILyoan/rust/turnoff_android_ndk_asm, r=thestinger

Now we don't need android ndk to generate unwind info for arm target thanks to LLVM upgrade.
This fix removes the ndk asm pass.
repr: handle tuple structs sanely

Closes #8919
switch __field__ hack to <unnamed_field>

avoids conflict with fields actually named `__field__`