Compilespeed improvements: Exists arguments and others

It turns out that exists is not inlinable, even if put into List.
We try to eliminate or hoist most closures passed to exists in Types.
There are some other small improvements as well.

Fix for crasher in recent commit.

The modification to specializesSym in 4a9270f2b did not account for
the case where the symbol is not present. This worked before because
an expression of the form "x.alternatives exists p" will smoothly
return false if x is NoSymbol.
More method hoisting.

Also avoided systematically to map (_.tpe) on parameters in favor of
lazy val paramTypes.
Splitting large methods into smaller ones.
First half of typed1 reorganization, to make it smaller and faster.
Second part of typed1 optimization

All cases factored out into separate methods. Cases ordered according to node frequency.
Method splitting for erasure, genJVM, parsers, scanners, uncurry

Also, added inlined List.foreach
More method splitting
Optimizations of isTrivial fields and methods
Replaced isTrivial lazy vals by custom scheme to save space.
Optimization to atOwner

Moved costly hashMap updates into SuperAccessors from general tree transformers and replaced by immutable map.
No longer uses generic hashCode in UniqueType, since case class hashCode is now the same and faster.
Made hashCode a method on Type to avoid megamorphic dispatch

profiling data shows that accessing the hashCode field has a cost of about 10% of fully hot running times. We speculate that it's megamorphic dispatch which is costing us this much.
Rewrote code so that UniqueType is not an abstract base class with the hashCode field.

Also removed fingerPrinting bloom filter on findMember because it caused complexity and did not gain us anything accdoring to the tests.

Made TypeVar an abstract case class to avoid extractor calls in TypeMap.
Optimizations to cut down on #closures created

Driven by profile data.
Make Array creation more efficient in hot places.

Overriden ClassTags in places where we allocate
a lot of Arrays.
Mark logging methods in `SymbolTable` with `@inline`.

Those two methods contribute 2% of Function0 allocation
when compiling `Vector.scala`.
Rework synchronization scheme of `UndoLog` for performance.

Introduced explicit locking mechanism that allows us to
make public methods of `UndoLog` that take thunks as
arguments final and thus `@inline`. Once inliner is able
to cope with inlining methods with exception handlers
we'll be able to get rid of significant (around 5%)
number of thunk allocation.
Don't allocate closure in List.hashCode.

Provided specialized version of hashing algorithm
for List that does not allocate the closure.

This saves us 124k closures allocated in a compiler
when compiling `Vector.scala` from std library.
That's aroudn 5% of all closures allocated for that
compiler run.
Moved five methods from LinearSeqOptimized to List

Curiously, profiling showed that these methods (in particular map) got slower when specialized in LinearSeqOptimized from their generic impl in TraversableLike.
I speculate that the virtual calls to head/tail/nonEmpty are more expensive than the closure creation which we save (Note that foreach IS specialized in List,
so head/tail are monomorphic, even though isEmpty still has two implementations.

If we confirm a speedup in this commit it would make sense to specialize more methods in LinearSeqOptimized again in List.
Specialize hashCode in TypeRef from the generic MurmurHashCode3 implementation.
Optimizations to SymTree and transform

Two optimizations:

(1) Make SymTree a class rather than a trait to allow faster access to symbol
(2) Split itransform into several smaller methods and order cases according to expected frequency.