lookupRefined: check for AliasingBounds instead of TypeBounds with equal bounds

It turns out that the problematic cases fixed in the previous commit only occurs
because we create type aliases with info of type MatchAlias instead of TypeAlias
if their rhs is an applied match type (Namer#TypeDefCompleter#typeSig calls
`toBounds` on the rhs which does `if (self.isMatch) MatchAlias(self)`).

I'm not sure if there is a good reason for that (and if so, do we need to be
careful to avoid loops when dealiasing MatchAlias? `lookupRefined` doesn't
actually loop on the alias but maybe it should?) or if we should change the
logic in Namer to return a TypeAlias instead.

Author: smarter

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1548,8 +1548,10 @@ object Types {
       @tailrec def loop(pre: Type): Type = pre.stripTypeVar match {
         case pre: RefinedType =>
           pre.refinedInfo match {
-            case TypeBounds(lo, hi) if lo eq hi =>
-              if (pre.refinedName ne name) loop(pre.parent) else lo
+            case tp: AliasingBounds =>
+              // TODO: should we recurse on tp.alias? Can that lead to cycles if
+              // problematic if AliasingBounds is a MatchAlias?
+              if (pre.refinedName ne name) loop(pre.parent) else tp.alias
             case _ =>
               loop(pre.parent)
           }