CrossCastAnd: reimplement it in more compact way.

Note that there is a slight difference in behaviour:

it will be unconditionally adding cast even if its not needed.

For example in callsFoo1 cast is not needed(erasure will insert a correct one).
```
class A{
  private def foo = 1
  def callsFoo1(other: A & B): Int = other.foo
  def callsFoo2(other: B & A): Int = other.foo
}

trait B {
  def foo(i: Int) = i
}
```

Though as AndTypes are uncommon I do not expect this to have
 non-negligible impact on performance.

Author: DarkDimius

src/dotty/tools/dotc/transform/CrossCastAnd.scala

@@ -20,29 +20,11 @@ class CrossCastAnd extends MiniPhaseTransform { thisTransform =>
   override def phaseName: String = "crossCast"
 
   override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
-    if (tree.symbol.is(Flags.Private)) {
-      // all private member selections have a symbol
-      tree.qualifier.tpe.widen match {
-        case t @ AndType(l, _) =>
 
-        // find a component of and type that owns the symbol
-        def findType(tp: Type): Type = {
-            tp match {
-              case AndType(l, r) =>
-                findType(l).orElse(findType(r))
-              case t =>
-                if (t.decl(tree.symbol.name).suchThat(_ == tree.symbol).exists)
-                  t
-                else NoType
-            }
-          }
-
-          val tp = findType(t)
-          if (l eq tp) tree
-          else tree.qualifier.asInstance(AndType(tp, tree.qualifier.tpe)).select(tree.symbol)
-        case _ => tree
-      }
-    }
-      else tree
+    lazy val qtype = tree.qualifier.tpe.widen
+    val sym = tree.symbol
+    if (sym.is(Flags.Private) && qtype.typeSymbol != sym.owner)
+      cpy.Select(tree)(tree.qualifier.asInstance(AndType(qtype.baseTypeWithArgs(sym.owner), tree.qualifier.tpe)), tree.name)
+    else tree
   }
 }