Error handling guide

Now that we've done `fail` -> `panic`, I feel bringing back the error handling guide is a good idea. We had one long ago, but it was removed when conditions were removed.

This doesn't cover the new FromError stuff, but I feel like it's already useful in this state, so I'm sending this PR now.
So for example in rustc we have the `ast::Expr_` enum, which enumerates all the possible expression nodes. One of the variants is `ExprIfLet`, however, in most of the components of the compiler encountering a value of that variant is a contract violation because the `if let` construct is desugared at a very early stage, immediately after a program is parsed.

This is the sort of a thing that I tend to use `unreachable!()` for and I think it's good for: expressing paths in the control flow that should not be reached according to an implicit contract enforced in a different part of my program. This is a bit subtle but still different than using it for essentially "hacking" the compiler to accept your program.

Anyway, I am being slightly pedantic here, I just thought that we could do better here, how about something like this:

```rust
enum Event {
    Rust10ShipsIn2015
}

fn probability(_: &Event) -> f64 {
    0.8
}

fn descriptive_probability(event: Event) -> &'static str {
    match probability(&event) {
        1.00          => "certain",
        0.00          => "impossible",
        0.00 ... 0.25 => "very unlikely",
        0.25 ... 0.50 => "unlikely",
        0.50 ... 0.75 => "likely",
        0.75 ... 1.0  => "very likely",
        _ => unreachable!()
    }
}

fn main() {
    std::io::println(descriptive_probability(Rust10ShipsIn2015));
}
```

Feel free to cut down if you think it's a good fit.