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)
With `where` clauses, I'm tempted to try to construct some sort of ad-hoc type destructuring device like this:

```rust
mod detail {
    pub trait IsSameType {}
    impl<T> IsSameType for (T, T) {}
}

pub trait Add<Result> {
    fn add<T, U>(&T, &U) -> Result
        where ((T, U), Self) : detail::IsSameType;
}
```

but I'm not sure whether it's actually possible to implement that method anymore. ;)