Improve simplifications of type projections.

An example where this helps:

Previously, the private value `mnemonics` in Coder.scala was fof the form

     Lambda$IP { ... } # Apply

It now simplifies to a Map[...] type.
Make reduceProjection use lookupRefined

Needed some fixes to lookup refined. The potential alias
type is now calculated by taking the member of the original
refined type, instead of by simply following the refined info.
This takes into account refinements that were defined after
the refinement type that contains the alias.

The change amde another test (transform) hit the deep subtype limit,
which is now disabled.
Fixed type adaptation problem in checkBounds

We need to adapt type parameter bounds with an as-ssen-from to the
prefix of the type constructor.

Makes pos/boundspropagation pass.
More robust TypeVar printing.

Avoid the crash if origin is not associated with a bound in the
current constraint.
More robust isSetter test.

Avoids cyclic references caused by forcing info too early.
Changed underlying type of RefinedThis

Now: The underlying refined type. Was: The parent of the type.
We need the change because RefinedThis is used as a narrowed version
of the underlying refinedType (e.g. in TypeComparer rebase), and the old
scheme would lose a binding of that type.
Fixes in TypeComparer for RefinedTypes.

The previous scheme did not propagate bounds correctly. More generally,
given a comparison

     T { X <: A }  <:   U { X <: B }

it would errenously decompose this to

     T <: U, A <: B

But we really need to check whether the total constraint for X in T { X <: A }
subsumes the total constraint for X in T { X <: B }

The new scheme propagates only if the binding in the lower type is an alias.
E.g.

    T { X = A }  <:   Y { X <: B }

decomposes to

    T { A = A }  <:   U, A <: B

The change uncovered another bug, where in the slow path we too a member relative to a refined type;
We need to "narrow" the type to a RefinedThis instead. (See use of "narrow" in TypeComparer).
That change uncovered a third bug concerning the underlying type of a RefinedThis. The last bug was fixed in a previous commit (84f32cd814f2e07725b6ad1f6bff23d4ee38c397).

Two tests (1048, 1843) which were pos tests for scalac but failed compling in dotc have
changed their status and location. They typecheck now, but fail later. They have been
moved to pending.

There's a lot of diagnostic code in TypeComparer to figure out the various problems. I left it in
to be able to come back to the commit in case there are more problems. The checks and diagnostics
will be removed in a subsequent commit.
Fix to checkBounds

Need to account for the fact that some argument types may be TypeBoudns themselves.
The change makes Jason's latest example work.
Take off the training wheels for refined type comparisons.
checkBounds refactoring

Move core logic to TypeOps, only leave error reporting in Checking.
That way, we have the option of re-using the code as a simple test
elsewhere.
Better printing of variant types with wildcard arguments.

We used to approximate these by their bounds, but this is confusing.
See comment in printbounds.scala.
Updated refinement checking.

Toucher checks, but only deprecated warnings instead of errors.
Added and corrected tests

to reflect last commit.
Cyclicity checking independent of positions.

More robust cyclicity check which does not depend on source positions.
Fixed cycle detection.

Now detects the cycles reported by @retronym
Simpler cycle detection

Turns out that the last commit was a red herring. None of the hoops
it jumped though was necessary. Instead there was a bug in isRef
which caused `&` to erroneously compute T & Int as Int.

The bug was that we always approximated alias types by their high bound. But
in the present case, this leads to errors because U gets 'bounds >: Nothing <: Any',
but it was still an alias type (i.e. its Deferred flag is not set). The fix
dereferences aliases only if their info is a TypeAlias.
Added test case from SI-6169
Merge pull request #238 from dotty-staging/fix/bounds-propagation-v2

Fix/bounds propagation v2
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.