RFC: error conventions and syntactic support (including changes to macro syntax)

This RFC sets out a vision for refining error handling in Rust, in two
parts:

* A stronger set of conventions around `fail!` and `Result`
* Sugar to make working with `Result` highly ergonomic

In a nutshell, the proposal is to isolate uses of `fail!` to an extremely small
set of well-known methods (and assertion violations), with all other kinds of
errors going through `Result` for maximal flexibility. Since the main downside
of taking this extreme position is ergonomics, the RFC also proposes notation
for consuming `Result`s:

* Change macro invocation syntax from `macro_name!` to `@macro_name`.
* Use `foo!` for today's `foo.unwrap()`
* Use `foo?` for today's `try!(foo)`

While the two parts of this proposal reinforce each other, it's possible to
consider each of them separately.

[Rendered](https://github.com/aturon/rfcs/blob/error-conventions/active/0000-error-conventions-and-sugar.md)
I find the below far more visually appealing than the above.

Likewise, I find the `?` example nicer under the modifier-on-identifiers format:

```rust

fn write_info(info: &Info) -> Result<(), IoError> {
    let mut file = File::open_mode?(&Path::new("my_best_friends.txt"), Open, Write);
    file.write_line?(format!("name: {}", info.name).as_slice());
    file.write_line?(format!("age: {}", info.age).as_slice());
    file.write_line?(format!("rating: {}", info.rating).as_slice());
    Ok(());
}
```

Maybe I just find the series of lines ending with `...?;` very visually jarring. . .