SI-7475 Less eager redundancy elimination in pattern typing

Usually, the type of a pattern binder is an intersection of the
scrutinee type and the pattern type, where this intersection
eliminates redundancies so that `intersect(Sub, Super)` will
just be `Sub` (where `Sub` <:< `Super`).

But, if we are nested in `Super` there is an observable difference
between `Sub` and `Sub with Super`. Only the latter will allow
use to select private members of `Super`.

This commit modifies `intersect` to be context-sensitive in
the elimination of redundant elements of the intersection.
If we can access a dummy private symbol of the high type, we
retain it.

The test case types as follows:

    % qbin/scalac -Xprint:typer -Xprint-types test/files/pos/t7475f.scala
    [[syntax trees at end of                     typer]] // t7475f.scala
    package <empty>{<empty>.type} {
      class C extends scala.AnyRef {
        def <init>(): C = {
          C.super{C.super.type}.<init>{()Object}(){Object};
          (){Unit}
        }{Unit};
        private def foo: Any = 0{Int(0)};
        this{C} match {
          case (d @ (_{D}: D){C with D}){C with D} => d.foo{Any}
        }{Any}
      };
      object C extends scala.AnyRef {
        def <init>(): C.type = {
          C.super{C.type}.<init>{()Object}(){Object};
          (){Unit}
        }{Unit};
        def test(c: C): Any = c{C} match {
          case (d @ (_{D}: D){C with D}){C with D} => d.foo{Any}
        }{Any}
      };
      class D extends C {
        def <init>(): D = {
          D.super{D.super.type}.<init>{()C}(){C};
          (){Unit}
        }{Unit}
      };
      object Other extends scala.AnyRef {
        def <init>(): Other.type = {
          Other.super{Other.type}.<init>{()Object}(){Object};
          (){Unit}
        }{Unit};
        def test(c: C): D = c{C} match {
          case (d @ (_{D}: D){D}){D} => d{D}
        }{D}
      }
    }