Trait based inheritance

This is largely based upon #9 and #91, but fleshed out to make an actual inheritance proposal.
My preferences here would be:

    #[first_field]   -> super
    mem::transmute() -> mem::force_transmute()
    Cast/Coercible   -> Transmute
    cast()/coerce()  -> transmute()
    HasPrefix/Extend -> Extends
    Any/Typed        -> Dynamic

Rationale:

 * (`#[first_field]` vs. `super`: See above.)
 * The word Rust uses for no-op bit-level reinterpretations is "transmute". So it makes sense to use this word here, because that's what we're doing.<sup>1</sup> The safety of the plain `transmute()` function would be assured by the presence of `Transmute` impls, while the current unrestricted, `unsafe` version would be renamed to e.g. `force_transmute()`.
 * Using the word "extend" here is a great idea! I think `Sub: Extends<Super>` reads better.
 * It makes tons of sense for the trait used to obtain dynamic typing to be called `Dynamic`. And e.g. `Box<Dynamic>` reads very well.

<sup>1</sup> The earlier name `Coercible` has already mislead some people into thinking that it has something to do with "coercions", by which Rust means "automatic compiler-inserted non-representation-preserving conversions", when in fact it doesn't.