Improve efficiency of updated

Added utility method to create a HashTrieSet with two leaf HashSets with different hash
Used said utility method instead of creating a temorary HashTrieSet with an empty elems array
Added assertions to HashTrieSet to validate tree
Added test that should cover all code paths of the changes done in SI-6220

This test will pass even with an older version of the scala library, since as mentioned this is just a performance improvement.
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.

--

(@gkossakowski): This commit contains also a fix to crasher
prepared by @paulp. I squashed that commit and kept the
test-case that came with it.
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.