Resolve name when named imp is behind wild imps

[dwijnand]

When a named import (such as import bug.util.List) is defined before
two clashing wildcard imports (import bug.util.*; import java.util.*)
the name "List" should resolve to it, rather than a resolution error
being emitted.

This was due to the fact that findRefRecur didn't return the
precedence at which it found that import, checkImportAlternatives used
the prevPrec to checkNewOrShadowed. Now we check against the entire
foundResult, allowing an early named import to be picked over later
wildcard imports.

Fixes #18529

[som-snytt]

I was dubious at first because the motivation is "how Java imports work".

My previous questions about name resolution in Dotty came down to understanding contexts not scopes. However, the spec only talks about scopes.

Scala 2 has the same current behavior. As a lover of wildcards, why doesn't that come up more often?

I must further spool up findRef; in particular, I don't understand what the previous recurAndCheckNewOrShadowed addresses, as the test was strange.

So with a grain of salt, this modified example from the spec, with an ambiguating import, and a second import to disambiguate, is still ambiguous:

package p {                   // `X' bound by package clause
  import p.X  // attempt to disambiguate
  object Y {
    println(s"L4: $X")          // `X' refers to `p.X' here
    locally {
      import q._                // `X' bound by wildcard import
      import p._                // ambiguating
      println(s"L7: $X")        // was: `X' refers to `q.X' here
    }
  }
}

where

package p {
  object X { val x = 1; val y = 2 }
}

package q {
  object X { val x = true; val y = false }
}

yielding

➜  i18529 ~/projects/dotty/bin/scalacQ -d ~/sandbox -cp ~/sandbox spec-mini.scala
-- [E049] Reference Error: spec-mini.scala:9:21 --------------------------------
9 |      println(s"L7: $X")        // `X' refers to `q.X' here
  |                     ^
  |                     Reference to X is ambiguous.
  |                     It is both imported by name by import p.X
  |                     and imported subsequently by import q._

That is unchanged from 3.5.2 (actually), but Scala 2 complains about the competing wildcards:

spec-mini.scala:9: error: reference to X is ambiguous;
it is imported twice in the same scope by
import p._
and import q._
      println(s"L7: $X")        // `X' refers to `q.X' here
                     ^

This variant of the test works as expected, and 3.5.2 complains about the wildcards:

package bug.code

import bug.util.List

class Lister {
  import bug.util.*
  import java.util.*
  import scala.collection.immutable.*
  def f(xs: List[Int]): Unit = ()
}

[odersky]

Can we piush this to staging please? That makes it easier for me to run my own diff tool.

It's going to be difficult to review, since there are a lot of changes in code that I know to be very subtle.