Implement io::native::file
Implement io::native::stdio
Implement io::native::process
Implement rt::io::stdio

Additionally, this moves the prelude imports of print/println from std::io to
std::rt::io.

Closes #6846
Implement BufferedReader.{read_until, read_line}

These two functions will be useful when replacing various other counterparts
used by std::io consumers.
Move std::run off of std::io

This changes the implementation to instead use rt::io::native::process as well
as an example of using those bindings.
Migrate users of io::fd_t to io::native::file::fd_t
Remove usage of io::FILE_writer
Remove some users of io::file_reader
Make the file::DirectoryInfo trait public

This was just a mistake that it was hidden.
auto merge of #9749 : alexcrichton/rust/less-io, r=brson

This implements a number of the baby steps needed to start eliminating everything inside of `std::io`. It turns out that there are a *lot* of users of that module, so I'm going to try to tackle them separately instead of bringing down the whole system all at once.

This pull implements a large amount of unimplemented functionality inside of `std::rt::io` including:

* Native file I/O (file descriptors, *FILE)
* Native stdio (through the native file descriptors)
* Native processes (extracted from `std::run`)

I also found that there are a number of users of `std::io` which desire to read an input line-by-line, so I added an implementation of `read_until` and `read_line` to `BufferedReader`.

With all of these changes in place, I started to axe various usages of `std::io`. There's a lot of one-off uses here-and-there, but the major use-case remaining that doesn't have a fantastic solution is `extra::json`. I ran into a few compiler bugs when attempting to remove that, so I figured I'd come back to it later instead. 

There is one fairly major change in this pull, and it's moving from native stdio to uv stdio via `print` and `println`. Unfortunately logging still goes through native I/O (via `dumb_println`). This is going to need some thinking, because I still want the goal of logging/printing to be 0 allocations, and this is not possible if `io::stdio::stderr()` is called on each log message. Instead I think that this may need to be cached as the `logger` field inside the `Task` struct, but that will require a little more workings to get right (this is also a similar problem for print/println, do we cache `stdout()` to not have to re-create it every time?).