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)
Oh, so the trait coherence rules actually only care about the number of `impl` blocks, not the number of concrete implemented traits? Interesting. And it looks like you're right, I can verify that in a quick test. Still, seems pretty odd. And I still want to know how `<() as Add>::add` is supposed to be typed, because `<() as Add<T, T, T>>::add` is not a type, it's an expression. I guess it would just be considered an unconstrained type though, preventing it from being inferred properly.

I thought about suggesting the syntax `<() as Add<L,R,S>>::add`, which would need to be a modification to the UFCS proposal (I glanced over it, but didn't see that in there, all the examples left the trait unparameterized, as in `<() as Add>`). I'm not sure if that's particularly useful though.

In any case, given this rule for trait coherence, it seems like we can skip the tuple stuff altogether. Instead do something like

```rust
// in mod ops
mod impl {
    pub trait Add<LHS,RHS,Result> {
        fn add(lhs: &LHS, rhs: &RHS) -> Result;
    }
}

pub trait Add<RHS,Result> {
    fn add(&self, rhs: &RHS) -> Result;
}

impl<LHS,RHS,Result> Add<RHS,Result> for LHS
where (LHS,RHS) : impl::Add<LHS,RHS,Result>
{
    fn add(&self, rhs: &RHS) -> Result {
        <(Self,RHS) as impl::Add>::add(self, rhs)
    }
}
```

With this, you can now just say

```rust
use AddImpl = std::ops::impl::Add;

impl AddImpl<Complex, int, Complex> for (Complex, int) { ... }
impl AddImpl<Complex, Complex, Complex> for (Complex, Complex) { ... }
impl AddImpl<int, Complex, Complex> for (int, Complex) { ... }
```

This looks similar to the `Add` impls in the RFC, but by using split traits like this, we can skip the `()` nonsense. Usage would now just look like

```rust
fn reduce<T:Clone + Add<T,T>>(xs: &[T]) -> T {
    let mut accum = xs[0].clone();
    for x in xs.slice_from(1) {
        accum = accum.add(&x);
    }
}
```

This also skips the need for a global function. And in fact all existing code that references `Add<RHS,Result>` bounds will continue to work. The only change is the implementation of the trait.