Fix for exponential compile time in specialization.

Review by @prokopec.
better module classes support in the reflection API
Improves backward compatibility of manifests

1) type ClassManifest[T] = ClassTag[T] (solves a problem
with toArray[T: ClassManifest] defined on most of the collections;
if these types weren't aliases, then we won't be able to change
the signature of that method to toArray[T: ClassTag], because
that would break source compatibility for those who override
toArray in their custom collections)

2) Compiler-generated manifests no longer trigger deprecation warnings
(this is implemented by using ClassManifestFactory instead of ClassManifest
and ManifestFactory instead of Manifest)

3) Deprecation messages got improved to reflect the changes
that were introduced in 2.10.0-M4.
further improves reflection printers
removes ClassTag.String and TypeTag.String

TypeTag.String is removed because it's unclear whether it should point to
scala.Predef.String or to java.lang.String. ClassTag.String is removed to
be consistent with TypeTag.String.

This requires re-bootstrapping, because Definitions.scala in locker
expects classTag[String] being automatically generated, whereas starr
disagrees with locker on how to generate that class tag.
miscellaneous cleanup
reify no longer dealiases symbols and types

this uncovers a bug in toolboxes: https://issues.scala-lang.org/browse/SI-6007
however that bug is not critical, so it will be dealt with later
Merge pull request #801 from paulp/issue/exponential-spec

Fix for exponential compile time in specialization.
Merge pull request #808 from scalamacros/topic/moduleclass

better module classes support in the reflection API
Merge pull request #810 from scalamacros/pullrequest/manifests-and-ticket6005

two pullrequests from this morning, combined to merge changes to starrs
SI-5830 switches: support guards, unreachability

turn switches with guards into guard-free switches by collecting all cases
that are (possibly) guarded by different guards but that switch on the same constant,
and pushing the implied if-then-else into the collapsed case body

```
case C if G1 => B1
case C if Gi => Bi
case C if GN => BN
```

becomes

```
case C => if (G1) B1
     else if (Gi) Bi
     else if (GN) BN
     else default() // not necessary if GN == EmptyTree
```

default() is a jump to the default case; to enable this, we wrap a default() { } labeldef
around the last case's body (the user-defined default or the synthetic case that throws the matcherror)
so we can jump to the default case after the last guard is checked
(assuming unreachability is checked, once we ended up in a non-default case,
one of the guards either matches or we go to the default case)

the unreachability analysis is minimal -- we simply check (after rewriting to guard-free form)
that:
  - there are no duplicate cases
  - the default case comes last

misc notes:
  - can't jump in exception handlers (TODO: a more fine-grained analysis on when we need to jump)
  - work around SI-6015 (test file run/t5830.scala crashed the inliner)
  - propagate type of case body to label def of default case
    (needed for existentials, see e.g., t2683)
  - the default(){} LabelDef breaks SelectiveANFTransform -- workaround: don't write guarded switches in CPS code
    (do the above transformation manually)
-Ypatmat-debug
WIP: SI-4691
WIP: SI-6008
wip si-6008: prune redundant type test