Fix of intersection not empty

The bug caused new version of FirstTransform to compile with errors.
Fixed data race in ResolveSuper

The datarace happened because for method "transform" implemented
by ResolveSuper which disambiguated overridden methods.
Previously, there was a reference FirstTransform.this.transform
of type termRefWithSig to the method implemented in a super trait. Now the same
reference points to the newly implemented method.

Solved because ResolveSuper now generates symbolic references.
Removed println's left accidentally in code base.
Allow deep subtypes in dotc_transform.

The clause got accidentally dropped in the rebase.
Merge pull request #242 from dotty-staging/fix/mixins

Fix/mixins
Merge pull request #254 from dotty-staging/fix/newArray-v2

Fix array creation v2
Fix TreeTransfrom ignoring SeqLiterals.
Merge pull request #259 from dotty-staging/fix/tree-transforms-seq-literal

Fix TreeTransfrom ignoring SeqLiterals.
made ArrayType constructor phase aware

Avoid to create ArrayTypes after erase.

Note that the *extractor* does not recognize JavaArrayTypes as
ArrayTypes. Doing so would create an infinite loop in sigName.
Generally, we do not want to ppaper over the difference when analysing
types.
Simplification in type assigning SeqLiterals
Replace `==` with `eq` when determining unique types

When hash-consing TypeBounds, RefinedTypes and NamedTypes, we
now check the argument types with `eq`, where before it was `==`.
This is necessary for TypeBounds, because it makes a difference
whether a TypeBound has `eq` parts (then it is a type alias) or not.
So we cannot merge type aliases with non-aliases.

The symptom of the problem was when compiling Patterns.scala twice with
the new SeqLiterals phase (next commit) enabled. On second run, we encountered
an ArrayType[>: String <: String], even if we only created an ArrayType[String].
This was a consequence of the two types being identified by uniques.

Todo: Change the system so that type aliases are recognized more robustly.
But the present change seems to be useful anyway because it speeds up
uniques hashing. I verified that the stricter condition on uniques creates less
than 1% more types than before. So the speedup of hashing looks worthwhile.
Add new SeqLiterals phase.

Replaces SeqLiterals by JavaSeqLiterals, because the latter's
(array-)type is preserved after erasure.