Unified algebraic datatype representation implementation, initial version.

Later changes on this branch adapt the rest of rustc::middle::trans
to use this module instead of scattered hard-coded knowledge of
representations; a few of them also have improvements or cleanup for
adt.rs (and many added comments) that weren't drastic enough to justify
changing history to move them into this commit.
Convert match on enums to use trans::adt.
Convert type_of to use trans::adt.
Avoid unnecessary casts in struct_GEP
Re-add discriminant range annotations
Add a test for enum discriminant range overflow.

It causes an LLVM assertion for every host/target word-size combination
on incoming at the time of this writing.
Handle unit-like types specially.

This change remains separate from the addition of adt.rs, even though
it's necessary for compatibility with pre-trans::adt representation,
to serve as an example of a change to the representation logic.
Wrap const structs in as many LLVM structs as the non-const case.

This, like the previous change for unit-like enums, is only necessary
until everything is fully converted to use trans::adt.
Factor out discriminant loading more, for use in casts.
Renovate expr_tup translation
Convert expr_struct to use adt, and try to share code with tuples.
Renovate nullary variant construction
Renovate field projection expressions
Convert the rest of the adt GEPi's in _match
Add regression tests for a subtle aspect of expr_struct translation.

The first is reduced from a case in rustdoc (originally involving an
ARC); the other is related.  No committed version has gotten these
wrong, but when I broke them it showed up only in rustdoc; there was
nothing in the test suite (or the compiler!) that failed.

The general issue is that the statics and trans have to agree on order
of evaluation, or else you get use-after-move-out-of errors at runtime.
Convert newtype "dereference" to trans::adt.

Note that in the ByValue case (which can't happen? yet?) we're still
effectively bitcasting, I think.  So this change adds a way to assert
that that's safe.

Note also, for future reference, that LLVM's instcombine pass will turn
a bitcast into a GEP(0, 0, ...) if possible.
Convert const ADT construction to trans::adt.

Also converts const cast-from-enum, because it used the same routine to
get the discriminant as what's renovated to construct the enums.

Also fixes ICE on struct-like variants as consts, and provides a slightly
less bad ICE for functional-update-like struct expressions in consts.
Test for struct-like variants in consts
Make functional-update struct consts not an ICE
Convert const field extraction to trans::adt