RFC: overloaded slice notation

This RFC adds *overloaded slice notation*:

- `foo[]` for `foo.as_slice()`
- `foo[n..m]` for `foo.slice(n, m)`
- `foo[n..]` for `foo.slice_from(n)`
- `foo[..m]` for `foo.slice_to(m)`
- `mut` variants of all the above

via two new traits, `Slice` and `SliceMut`.

[Rendered](https://github.com/aturon/rfcs/blob/slice-notation/active/0000-slice-notation.md)
It should be possible to use this with other unsized types as well (i.e., structs with embedded `[T]` fields).

There are two ways to get the kind of generality you have in mind:

* HKT. In that case, the type "S" here could instead be a lifetime-indexed family of types, so you could use `StridedSlice` for example.

* Lifetime lifting. That is, rather than have the trait methods take `&self`, have them take `self` and `impl` the trait on reference types. (That's more generally a [way to encode HKTs](https://gist.github.com/aturon/e5813687e90be860d02c).) Problem is, auto-deref and auto-borrowing for method receivers doesn't work for this kind of case: if `foo: Vec<T>`, you'd have to write `(&foo)[]` to get a full slice, for example. You can hack around this in various ways, but it quickly gets pretty ugly.

I'm not sure if there's a design that would allow us to smoothly transition to an HKT type parameter later on. Worth thinking about.