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)
If `where` clauses are extended to support basic `==` comparison of types (which I think will be necessary if we get associated types), then you can do destructuring like

```rust
impl<T,L,R> Foo<T>
where T == (L,R)
{ ... }
```

Of course, this isn't very useful as written, because that's equivalent to just using `(L,R)` in place of `T`:

```rust
impl<L,R> Foo<(L,R)> { ... }
```

But that's an `impl` block. Presumably the need to get at the component types of the tuple is if they're needed in a type signature for one of the trait functions. In that case, if we had a way of introducing type parameters in a `trait` block that aren't actually considered parameters to the trait name, that would work. Either of the following two syntaxes could represent that:

```rust
pub trait<L,R> Foo<T>
where T == (L,R)
{ ... }
```

or

```rust
pub trait Foo<T>
where <L,R> T == (L,R)
{ ... }
```