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)
@huonw @nielsle , what I have in mind is something like this:

`#{#1.foo()} = |x| { x.foo() } = |&mut: x| { x.foo() }`
`#:{#1 + #2} = |: x, y| { x + y }`
`#&{#1 * #3} = |&: x, y, z| { x * z }`

Basically, `#{...}` introduces a simple closure implementing FnMut.
`#&{...} is a simple Fn closure.
`#:{...}` is a simple FnOnce closure.

Inside these closures, #1, #2, ..., is the notation for the (not declared) positional arguments. `#1` can also be simply `#`. (`#0` is "the closure environment", but we may forbid its usage.)

The closures can only have one expression inside like python lambdas, and nested simple closures are not allowed. (You cannot nest `#{...}` inside another `#{...}`, as it is not clear what the inner `#1`, `#2`s would be referring to.)

But you can use attributes inside a simple closure. Like `#{ #[foo] #1.baz()}`.

I took a page from Clojure, and I love the `#(...)` closure sugar there.

But there may be problems with type inference and method look-ups. Clojure doesn't care too much about a closure's arity (`#(+ &1 &2)` is variadic there) . But Rust do care, and we are going to gain multiple dispatch, which AFAIK, will make it possible to "overload" a method like `Foo::bar(&self, closure: [ClosureType])` for different closure types differing in arities, argument types and env passing styles.

How do we infer that? (Of course, when we cannot infer things, we can just ask the programmer to use the "full" closure notations.)