Code to handle overloaded unapply/unapplySeq methods

These were not handled before.
Added version settings -migration, -source
Annotation decorators for symbols

Added decorators for symbols that can query specific
annotations and annotation arguments (for now, -deprecated
and -migration are added)
Type#foreachPart

Added method to traverse all parts of a type.
Changed first phase normalization and improvements to TreeTransform

Two improvements to TreeTransform:

1) Added transformOther functionality which handles trees not handled by other parts
2) Passes down Mode.Pattern in the context when in a pattern.

TreeTransform no longer normalizes unknown trees but passes them to transformOther.
The former Companions phase has been renamed to FirstTransform. It now performs the
following optimizations:
 - adds companion objects (this was done before)
 - other normalizations that were formally done in TreeTransform,
 - rewrite native methods to stubs (this was formally done in RefChecks)
Detect cycles and protected legal ones with LazyRefs

Cycles are now detected early, when an info is first completed.
Legal, f-bounded cycles are broken by a LazyRef, which will construct
its type lazily. This makes checkBounds validation of AppliedTypeTrees work
(in FirstTransform). Formerly, this stackoverflowed despite the laziness
precautions in findMember.

Todo: Do the same for class files coming from Java and Scala 2.x.
LazyRefs break cycles for unpickled types

Insert LazyRefs to break cycles for F-bounded types that
are unpickled or read from Java signatures.
Re-enabled checkbounds tests

Now that F-bunded types are treated more robustly, we can check bounds for
non-emptyness during Typer.

This unvealed one wrong test (wonder how that passed scalac?), which got
moved to neg.
prepareStats should span all statement transforms

Statements are now transformed with the transform returned by prepareStats,
analogoys to the other prepare methods.
Initial version of RefChecks

This is still disabled, because the prepare machinery in transform
does not work yet. Concretely, prepare ops need to return a new TreeTransform
but that tree transform has an undefined phaase id.

We need some architectural changes to disentangle transforms from phases.
Made Phase a trait

... so that it can be combined with TreeTransform in a trait composition
in a future dientanglement of TreeTransforms and Phases.
Fixed fully qualified name of migration annotation
ParamAccessors are assumed to have definition

Would be flagged as unimplemented members in refChecks otherwise
Disentangle phases from treetransforms

TreeTransforms are no longer phases. This allows to generate
new transforms in prepare... methods without running into the
problem that thee new transforms are undefined as phases.

It also makes for a cleaner separation of concerns.
Module vals are lazy

Should have lazy flag set, otherwise forward reference checking would
fail for modules.

Note: LazyVals needed to be disabled because it also should transform
module vals, but didn't do this so far because it only tested the Lazy flag.
It turned out the module val transformation exposed some bugs in lazy vals
in that LazyVals creates symbols as a side effect and enters them into scopes.
Such mutations are allowed onyl in very specific cases (essentially only for local
throw-away scopes).
In refined printer, show only source modifier flags.

Used to show "mutable var x: T".
Narrow assertion for Scope#enter

Scopes are also used in overriding pairs, and there multiple types with
the same name can be entered in a scope. So the assert to the contrary
should be limited to typechecking only.
More targeted eta-lifting

Eta-lifting picked some arbitrary base type. It turned out that i94-nada failed once we add
a product trait to case classes (in the next commit) because Eta-Kifting picked Product
as the base type, even though the target type was bounded by Monad. We now change the scheme
so that the target type is included in the lifting, in order to avoid that we lift to
useless types.
Add Product{1,2} supertrait to case classes

Case classes with arity <= 1 now also get a ProductN parent trait.
This is necessary because we inherit productArity and Element methods
in case classes from the ProdictN trait.

Needed to add Product0 for this, which is not defined in Scala2.x.
Fix Object's scope after ersure

After erasure, former Any members become Object members.

Also, fixed some typos and added some TODOs on addBridges.