SI-8177 Account for refinements in AsSeenFromMap::classParameterAsSeen

Consider for a moment:

	scala> trait T[A] { val foo: { type B = A } = ???; def bar(b: foo.B) = () }
	defined trait T

	scala> object O extends T[Int] { val x: O.foo.B = 0 }
	defined module O

	scala> object O extends T[Int] { bar(0) }
	<console>:8: error: type mismatch;
	 found   : Int(0)
	 required: O.foo.B
	    (which expands to)  A
	       object O extends T[Int] { bar(0) }
	                                     ^
This seems non-sensical: why should `foo.B` unify with `Int` in the
first case but not the second?

At the heart of asSeenFrom, we recurse through the prefix and
the owners of the "seen from" class symbol, taking the base
type of the successive prefixes at the class symbol.

For example, above, we want to eventually determine that:

    O.type baseType T = T[Int]
    AIn = Int

But in this example, we run into a snag. The type of the method
bar has *already* been seem from O, which has had to create a
new symbol for the refined type of `foo`, `{ type B = Int}`.

Suddenly we find that this this type no longer includes the
refinement class symbol representing `{type B = A}`; and the
call to `nextBase` yields `NoType`. This aborts the search up
the prefix.

I believe that this is the same quandry resolved in type comparisons
by `isEligibleForPrefixUnification`.

The remedy is actually pretty simple: just use the prefix of the
type rather than the prefix of the base type when hit a refinement
class.

As with any change to this part of the code, we could expect more
accurate types in subclasses which could lead to changes in
erased signatures.

TODO:

qbin/scalac -Xprint:uncurry sandbox/test.scala
[[syntax trees at end of                   uncurry]] // test.scala
package <empty> {
  abstract trait Thing extends Object {
    def /*Thing*/$init$(): Unit = {
      ()
    };
    type A;
    private[this] var p: Thing.this.A = _;
    <accessor> def p(): Thing.this.A = Thing.this.p;
    <accessor> def p_=(x$1: Thing.this.A): Unit = Thing.this.p = x$1
  };
  class A[T] extends Object {
    final <paramaccessor> private[this] val x: Thing{type A = T} = _;
    final <stable> <accessor> <paramaccessor> def x(): Thing{type A = T} = A.this.x;
    def <init>(x: Thing{type A = T}): A[T] = {
      A.super.<init>();
      ()
    };
    type Q = T;
    def x1(): T = A.this.x().p();
    def x2(): T = A.this.x().p();
    def x3(): T = A.this.x().p()
  };
  class B extends A[Int] {
    def <init>(): B = {
      B.super.<init>(null);
      ()
    };
    def y1(): Int = B.this.x1();
    def y2(): Int = B.this.x2();
    def y3(): T = B.this.x3()
  }
}
WIP