Avoid even more false negatives in overload pruning

The changes two commits ago were not enough to handle i21410b.scala because we
end up checking:

    Tuple.Map[WildcardType(...), List] <: (List[Int], List[String])

which fails because a match type with a wildcard argument apparently only gets
reduced when the match type case is not parameterized.

To handle this more generally we use AvoidWildcardsMap to remove wildcards from
the result type, but since we want to prevent false negatives we start with
`variance = -1` to get a lower-bound instead of an upper-bound.

Author: smarter

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

@@ -2122,16 +2122,23 @@ trait Applications extends Compatibility {
      *  section conforms to the expected type `resultType`? If `resultType`
      *  is a `IgnoredProto`, pick the underlying type instead.
      *
-     *  Using approximated result types is necessary to avoid false negatives
-     *  due to incomplete type inference such as in tests/pos/i21410.scala.
+     *  Using an approximated result type is necessary to avoid false negatives
+     *  due to incomplete type inference such as in tests/pos/i21410.scala and tests/pos/i21410b.scala.
      */
     def resultConforms(altSym: Symbol, altType: Type, resultType: Type)(using Context): Boolean =
       resultType.revealIgnored match {
         case resultType: ValueType =>
           altType.widen match {
             case tp: PolyType => resultConforms(altSym, tp.resultType, resultType)
             case tp: MethodType =>
-              constrainResult(altSym, wildApprox(tp.resultType), resultType)
+              val wildRes = wildApprox(tp.resultType)
+
+              class ResultApprox extends AvoidWildcardsMap:
+                // Avoid false negatives by approximating to a lower bound
+                variance = -1
+
+              val approx = ResultApprox()(wildRes)
+              constrainResult(altSym, approx, resultType)
             case _ => true
           }
         case _ => true

tests/pos/i21410b.scala

@@ -0,0 +1,10 @@
+object Test:
+  def foo[T](x: Option[T]): T = ???
+  def foo[T <: Tuple](x: T): Tuple.Map[T, List] = ???
+
+  val tup: (Int, String) = (1, "")
+
+  val x = foo(tup)
+  val y: (List[Int], List[String]) = x
+
+  val x2: (List[Int], List[String]) = foo(tup) // error