Where clauses for more expressive bounds

Add `where` clauses, which provide a more expressive means of specifying trait parameter bounds. A `where` clause comes after a declaration of a generic item (e.g., an impl or struct definition) and specifies a list of bounds that must be proven once precise values are known for the type parameters in question.

Main benefits:

- Express bounds on types derived from type parameters, e.g. `Option<T>` where `T` is a type parameter.
- Permits true multiple dispatch.

[Rendered view.](https://github.com/nikomatsakis/rfcs/blob/where-clauses/active/0000-where.md)
Actually even this is unnecessarily repetitious. The `Add` impl trait has no need to be parameterized on the LHS or RHS, as those are both part of the tuple type it's implemented on.

(also I realized `impl`, being a keyword, can't be a mod name, so that's changed)

```rust

mod impls {
    pub trait Add<Result> {
        fn add(tup: &Self) -> Result;
    }
}

impl impls::Add<Complex> for (Complex, int) {
    fn add(_: &(ref lhs, ref rhs): &(Complex, int)) -> Complex { ... }
}
```

So this trades a bit of DRY in the `impl` line for a bit of messiness in the function signature (granted, the tuple could be destructured in the first line of the implemenation, or could even use the `Tuple2` methods to avoid destructuring at all).