RFC: IO simplification

This RFC proposes a significant simplification to the I/O stack distributed with
Rust. It proposes to move green threading into an external Cargo package, and
instead weld `std::io` directly to the native threading model.

The `std::io` module will remain completely cross-platform.

[Rendered](https://github.com/aturon/rfcs/blob/io-simplification/active/0000-io-simplification.md)
Actually, I've been working personally on a hack to implement green threads that don't need dynamically inserted yields. What one has is a very slow timer so that most context switches will be purely user-land and fast but for fairness a few will be OS generated signals. Writing async-signal-safe timer signal based context switches is a pain but should be possible to do it by abusing `rt_sigreturn` like the following:

~~~C
static void handle_fiber_switch_signal(int sig, siginfo_t *info,
                                       void *untyped_ucontextp)
{
    struct __ssg_pthread *self;
    struct __ssg_pthread *new_thread;
    ucontext_t *ucontextp;

    ucontextp = (ucontext_t*)untyped_ucontextp;

    if (_mylibc_pthread_yield_is_locked()) {
        return;
    }

    self = __mylibc_pthread_current_thread;
    new_thread = self->next;

    if (self != new_thread) {
        self->ucontext = *ucontextp;
#ifdef __linux__
        self->ucontext.uc_mcontext.fpregs = &self->ucontext.__fpregs_mem;
#endif

        self->saved_errno = errno;

        initialize_context(new_thread);

        *ucontextp = new_thread->ucontext;
#ifdef __linux__
        ucontextp->uc_mcontext.fpregs = &ucontextp->__fpregs_mem;
#endif
    }
}
~~~

This doesn't actually work because Linux rejects the stack frame as invalid but it should be possible to hack up the context so that the kernel will accept it. So yeah, inserting yields at every loop point isn't technically needed but just convenient.