Prefer non-varargs methods in overload resolution when tiebreaker

Fixes #24072

Add a tiebreaker in the `compare` method to prefer non-varargs methods over varargs methods when both alternatives are equally specific.

`isAsGood` function normally prefer varargs methods. However, it can fail to distinguish methods when wildcard types are involved with invariant type parameters.
For example:

```scala
def blub[T](a: Class[? <: T]): Unit // m1
def blub[T](a: Class[T], ints: Int*): Unit // m2
blub(classOf[Object])
```

Here, `compare(m1, m2)` returns 0 (ambiguous) because both `winsType1` and `winsType2` are false:
- `m2` is not as good as `m1` (this is correct: a varargs method can only be as good as another varargs method).
- `m1` is NOT as good as the `m2` because Class[? <: T] is not a subtype of Class[T] (Class is invariant)

The new tiebreaker resolves this ambiguities by preferring
non-varargs methods as a final comparison step when owner hierarchy and type-based comparisons don't distinguish the alternatives.

Author: tanishiking

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -2176,7 +2176,20 @@ trait Applications extends Compatibility {
           case  0 =>
             if winsType1 != winsType2 then if winsType1 then 1 else -1
             else if alt1.symbol == alt2.symbol then comparePrefixes
-            else 0
+            else
+              // Prefer non-varargs methods over varargs methods as a final tiebreaker.
+              // While `isAsGood` normally handles this, it can fail when wildcard types are involved.
+              // For example, when comparing:
+              //   def m[T](a: Class[? <: T]): Unit
+              //   def m[T](a: Class[T], ints: Int*): Unit
+              // Both winsType1 and winsType2 are false because Class[? <: T] is not
+              // a subtype of Class[T] (Class is invariant). This tiebreaker ensures the
+              // non-varargs method is preferred in such cases.
+              val alt1IsVarArgs = alt1.widen.isVarArgsMethod
+              val alt2IsVarArgs = alt2.widen.isVarArgsMethod
+              if alt1IsVarArgs == alt2IsVarArgs then 0
+              else if alt1IsVarArgs then -1  // alt2 (non-varargs) wins
+              else 1  // alt1 (non-varargs) wins
     end compareWithTypes
 
     if alt1.symbol.is(PhantomSymbol) && !alt2.symbol.is(PhantomSymbol) then -1

tests/run/overload_repeated/B_2.scala

@@ -13,6 +13,10 @@ object Test {
   def bar4[T](x: T): Int = 1
   def bar4[T](x: T, xs: T*): Int = 2
 
+  // https://github.com/scala/scala3/issues/24072
+  def bar5[T](a: Class[? <: T]): Int = 1
+  def bar5[T](a: Class[T], ints: Int*): Int = 2
+
   def main(args: Array[String]): Unit = {
     // In Java, varargs are always less specific than non-varargs (see
     // https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2),
@@ -28,5 +32,6 @@ object Test {
     assert(bar2("") == 1) // same in Scala 2
     assert(bar3("") == 1) // same in Scala 2
     assert(bar4("") == 1) // same in Scala 2
+    assert(bar5(classOf[Object]) == 1) // same in Scala2
   }
 }