std: Fully stabilize Option<T>

This commit takes a second pass through the `std::option` module to fully
stabilize any lingering methods inside of it.

These items were made stable as-is

* Some
* None
* as_mut
* expect
* unwrap
* unwrap_or
* unwrap_or_else
* map
* map_or
* map_or_else
* and_then
* or_else
* unwrap_or_default
* Default implementation
* FromIterator implementation
* Copy implementation

These items were made stable with modifications

* iter - now returns a struct called Iter
* iter_mut - now returns a struct called IterMut
* into_iter - now returns a struct called IntoIter, Clone is never implemented

This is a breaking change due to the modifications to the names of the iterator
types returned. Code referencing the old names should updated to referencing the
newer names instead. This is also a breaking change due to the fact that
`IntoIter` no longer implements the `Clone` trait.

These items were explicitly not stabilized

* as_slice - waiting on indexing conventions
* as_mut_slice - waiting on conventions with as_slice as well
* cloned - the API was still just recently added
* ok_or - API remains experimental
* ok_or_else - API remains experimental

[breaking-change]

auto merge of #19467 : japaric/rust/uc, r=alexcrichton

This PR moves almost all our current uses of closures, both in public API and internal uses, to the new "unboxed" closures system.

In most cases, downstream code that *only uses* closures will continue to work as it is. The reason is that the `|| {}` syntax can be inferred either as a boxed or an "unboxed" closure according to the context. For example the following code will continue to work:

``` rust
some_option.map(|x| x.transform_with(upvar))
```

And will get silently upgraded to an "unboxed" closure.

In some other cases, it may be necessary to "annotate" which `Fn*` trait the closure implements:

```
// Change this
|x| { /* body */}
// to either of these
|: x| { /* body */}  // closure implements the FnOnce trait
|&mut : x| { /* body */}  // FnMut
|&: x| { /* body */}  // Fn
```

This mainly occurs when the closure is assigned to a variable first, and then passed to a function/method.

``` rust
let closure = |: x| x.transform_with(upvar);
some.option.map(closure)
```

(It's very likely that in the future, an improved inference engine will make this annotation unnecessary)

Other cases that require annotation are closures that implement some trait via a blanket `impl`, for example:

- `std::finally::Finally`
- `regex::Replacer`
- `std::str::CharEq`

``` rust
string.trim_left_chars(|c: char| c.is_whitespace())
//~^ ERROR: the trait `Fn<(char,), bool>` is not implemented for the type `|char| -> bool`
string.trim_left_chars(|&: c: char| c.is_whitespace())  // OK
```

Finally, all implementations of traits that contain boxed closures in the arguments of their methods are now broken. And will need to be updated to use unboxed closures. These are the main affected traits:

- `serialize::Decoder`
- `serialize::DecoderHelpers`
- `serialize::Encoder`
- `serialize::EncoderHelpers`
- `rustrt::ToCStr`

For example, change this:

``` rust
// libserialize/json.rs
impl<'a> Encoder<io::IoError> for Encoder<'a> {
    fn emit_enum(&mut self,
                 _name: &str,
                 f: |&mut Encoder<'a>| -> EncodeResult) -> EncodeResult {
        f(self)
    }
}
```

to:

``` rust
// libserialize/json.rs
impl<'a> Encoder<io::IoError> for Encoder<'a> {
    fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
        F: FnOnce(&mut Encoder<'a>) -> EncodeResult
    {
        f(self)
    }
}
```

[breaking-change]

---

### How the `Fn*` bound has been selected

I've chosen the bounds to make the functions/structs as "generic as possible", i.e. to let them allow the maximum amount of input.

- An `F: FnOnce` bound accepts the three kinds of closures: `|:|`, `|&mut:|` and `|&:|`.
- An `F: FnMut` bound only accepts "non-consuming" closures: `|&mut:|` and `|&:|`.
- An `F: Fn` bound only accept the "immutable environment" closures: `|&:|`.

This means that whenever possible the `FnOnce` bound has been used, if the `FnOnce` bound couldn't be used, then the `FnMut` was used. The `Fn` bound was never used in the whole repository.

The `FnMut` bound was the most used, because it resembles the semantics of the current boxed closures: the closure can modify its environment, and the closure may be called several times.

The `FnOnce` bound allows new semantics: you can move out the upvars when the closure is called. This can be effectively paired with the `move || {}` syntax to transfer ownership from the environment to the closure caller.

In the case of trait methods, is hard to select the "right" bound since we can't control how the trait may be implemented by downstream users. In these cases, I have selected the bound based on how we use these traits in the repository. For this reason the selected bounds may not be ideal, and may require tweaking before stabilization.

r? @aturon

librustc_borrowck: add `#![feature(unboxed_closures)]`

libstd: add missing imports

Remove some unnecessary `move` keywords

libtest: use unboxed closures

librustc_driver: use unboxed closures

librustc_typeck: use unboxed closures

librustdoc: use unboxed closures

librustc_trans: use unboxed closures

librustc_trans: fix fallout

librustc_typeck: fix fallout

librustc: use unboxed closures

librustc_llvm: use unboxed closures

librustc_trans: fix fallout

librustc_back: use unboxed closures

librustc: fix fallout

libsyntax: use unboxed closures

Fix benches

libstd: use unboxed closures

librustrt: use unboxed closures

libregex_macros: use unboxed closures

libcollections: use unboxed closures

libserialize: use unboxed closures

libregex: use unboxed closures

libarena: use unboxed closures

libregex: fix fallout in doc tests

libregex: impl Replacer for FnMut(&Captures) -> String implementors

librustc: fix fallout

librbml: use unboxed closures in free functions

librbml: fix fallout

libserialize: use unboxed closures

librand: use unboxed closures in `distributions` module

libgraphviz: use unboxed closures in `LabelText` methods

libgetopts: use unboxed closures in `each_split_within`

libcore: use unboxed closures in `slice::raw` free functions

libcore: use unboxed closures in `float_to_str_bytes_common`

libcollections: use unboxed closures in `VecMap` methods

libgraphviz: fix fallout

libcollections: use unboxed closures in `[Clone]SliceAllocPrelude` methods

libcollections: use unboxed closures in `DList` methods

libcollections: use unboxed closures in `Vec` methods

libcollections: use unboxed closures in `Bitv` methods

libcollections: use unboxed closures in `TreeMap` methods

libcore: use unboxed closures in the `char` module

libcore: use unboxed closures in `Formatter` methods

libcore: fix fallout in doc tests

librustrt: fix fallout

libcoretest: fix fallout

Fix run pass test

libstd: fix fallout

libcore: use unboxed closures in the `finally` module

libcore: use unboxed closures in `SlicePrelude` methods

libcore: use unboxed closures in the fields of `MutSplits`

libstd: fix fallout

libcore: use unboxed closures in the fields of `Splits`

libcore: fix fallout in doctests

libcoretest: fix fallout in unit tests

libcollections: fix fallout in unit tests

librustdoc: fix fallout

libstd: fix fallout

libunicode: fix fallout

libcore: impl CharEq for FnMut(char) -> bool implementors

libcore: use unboxed closures in `ExactSizeIterator` methods

libcollections: fix unit tests

Fix run-pass tests

librustc: fix fallout

libregex: fix fallout

libcore: use unboxed closures in `IteratorExt` methods

libcore: use unboxed closures in the fields of `Unfold`

libcoretest: fix fallout

libcore: use unboxed closures in the fields of `Inspect`

libcore: use unboxed closures in the fields of `FlatMap`

libcore: use unboxed closures in the fields of `Scan`

libcore: use unboxed closures in the fields of `TakeWhile`

libcore: use unboxed closures in the fields of `SkipWhile`

librustdoc: fix fallout

libstd: fix fallout

libcollections: fix fallout

libcore: use unboxed closures in the fields of `FilterMap`

librustc_trans: fix fallout

libunicode: fix fallout

libcore: use unboxed closures in the fields of `Filter`

librustc_trans: fix fallout

librustc: fix fallout

libsyntax: fix fallout

libstd: fix fallout

librustrt: fix fallout

libcollections: fix fallout

libcore: use unboxed closures in the fields of `Map`

libcore: use unboxed closures in `Result` methods

Fix compile fail tests

librustc_trans: fix fallout

libcore: use unboxed closures in `Option` methods

auto merge of #19582 : nikomatsakis/rust/crateification, r=alexcrichton

r? @alexcrichton

auto merge of #19627 : steveklabnik/rust/testing_guide, r=cmr

Revamped testing guide

auto merge of #19695 : arthurtw/rust/master, r=steveklabnik

auto merge of #19685 : jbranchaud/rust/add-btreemap-iter-doctests, r=Gankro

Separate borrowck into its own crate and remove dead code as well.