Pin partial progress of #16018 with directional pos/neg tests

#16018 is a long-standing typer regression from Scala 2: passing a value
of type `J[? <: G[? <: M]]` (where J is a Java generic such as
java.lang.Iterable / java.util.List) through a method, then pattern-
matching the result with a subtype pattern plus a fallback `case other`,
breaks partial-function return-type inference.

The mbovel-style minimized case (a wildcard reached through `List.map`)
already compiles since 3.2.0. The akka-style case (wildcard reached
through Java-generic interop, with subtype + fallback patterns) still
fails on current main. The two halves form a directional matrix that
flips green/red as soon as either side moves -- ideal for catching both
forward fixes and silent regressions.

Files:
- tests/pos/i16018.scala
    f1: mbovel's minimized case -- regression test for the fixed half.
    f2: pure-Scala same-shape control -- confirms the bug is not in the
        wildcard-bearing parameter alone.
    f3: documents the explicit-widening workaround
        (`case g: SubT[...] @unchecked => (g: WiderT[...])`) so user
        code that adopts it does not silently break later.

- tests/neg/i16018.scala (+ .check)
    f1: java.lang.Iterable trigger.
    f2: java.util.List trigger.
    f3: same trigger via `.map` instead of `.collect`, showing it is not
        specific to partial functions over `collect`.

The error pattern is always identical:
    B := SubType[...] & {?N.CAP | xs.T}
i.e. the partial-function result type is constrained to the first
case's narrowed body type instead of the LUB of all case bodies. When
the underlying typer bug is fixed, the neg cases should compile and be
moved to tests/pos/i16018.scala.

No compiler changes; tests only.

Author: He-Pin

tests/neg/i16018.check

@@ -0,0 +1,23 @@
+-- [E007] Type Mismatch Error: tests/neg/i16018.scala:29:49 ------------------------------------------------------------
+29 |      case other                              => other // error
+   |                                                 ^^^^^
+   |                                                 Found:    (other : xs.T)
+   |                                                 Required: Test.SubContainer[Any, M] & xs.T
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i16018.scala:39:49 ------------------------------------------------------------
+39 |      case other                              => other // error
+   |                                                 ^^^^^
+   |            Found:    (other : ?1.CAP)
+   |            Required: Test.SubContainer[Any, M] & ?1.CAP
+   |
+   |            where:    ?1 is an unknown value of type scala.runtime.TypeBox[Nothing, Test.Container[Any, ? <: M]]
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i16018.scala:47:49 ------------------------------------------------------------
+47 |      case other                              => other // error
+   |                                                 ^^^^^
+   |                                                 Found:    (other : xs.T)
+   |                                                 Required: Test.SubContainer[Any, M] & xs.T
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg/i16018.scala

@@ -0,0 +1,48 @@
+// Documents the unfixed half of #16018.
+//
+// Each `f*` is a minimal *failing* shape that the bug report from akka
+// boils down to. Together with tests/pos/i16018.scala they pin the
+// trigger: passing a value of type `J[? <: G[? <: M]]` (where J is a
+// Java generic such as java.lang.Iterable / java.util.List) through a
+// method, then pattern-matching the result with a subtype pattern + a
+// fallback `case other`, breaks partial-function return-type inference.
+//
+// The error pattern is always the same: B := `SubType[...] & ?N.CAP`
+// instead of the LUB of the case bodies, where `?N.CAP` is a
+// capture-conversion skolem with bounds `[Nothing, G[? <: M]]`.
+//
+// When the underlying typer bug is fixed, these cases will start to
+// compile and should be moved to tests/pos/i16018.scala.
+
+object Test:
+
+  class Container[+S, +M]
+  class SubContainer[+S, +M] extends Container[S, M]
+
+  def seqOf[T](it: java.lang.Iterable[T]): scala.collection.immutable.Seq[T] = ???
+
+  // ---- f1: minimum trigger via java.lang.Iterable --------------------
+  def f1[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other // error
+    }
+
+  // ---- f2: same trigger via java.util.List ---------------------------
+  // Confirms it is not specific to Iterable but to any Java generic
+  // carrying the wildcard-bearing element type.
+  def f2[M](xs: java.util.List[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other // error
+    }
+
+  // ---- f3: same trigger via .map (not specific to collect) -----------
+  def f3[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).map {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other // error
+    }

tests/pos/i16018.scala

@@ -0,0 +1,91 @@
+// Regression test for #16018: type inference with `_ <: T` wildcards.
+//
+// Each `f*` exercises a *known-good* shape that the compiler must keep
+// inferring correctly. The complementary `f*` shapes that currently
+// regress are pinned in tests/neg/i16018.scala. Together they form a
+// directional matrix that flips green/red as soon as either side moves.
+//
+// Coverage axes for the positive matrix:
+//   1. Bug origin: mbovel's minimized case (was broken in 3.1.x).
+//   2. Pure-Scala collections never trigger the bug, regardless of
+//      wildcard depth or subtype-pattern interaction.
+//   3. Identity / generic helper methods over Scala types do not
+//      introduce skolems and therefore stay safe.
+//   4. The widening workaround for the akka-style failure must keep
+//      compiling so user code that adopts it does not silently break.
+
+object Test:
+
+  class Box[T](val value: T)
+  class Container[+S, +M]
+  class SubContainer[+S, +M] extends Container[S, M]
+
+  // ---- 1. mbovel's minimized case from #16018 ------------------------
+  // Was broken in 3.1.1 and 3.1.3, fixed since 3.2.0.
+  def f1[T](l: List[Box[? <: T]]): List[T] = l.map(_.value)
+
+  // 1b. Variant: returning the wildcard-bearing element preserved.
+  def f1b[T](l: List[Box[? <: T]]): List[Box[? <: T]] = l.map(identity)
+
+  // ---- 2. Pure-Scala, no Java involvement ----------------------------
+  // Identical structure to the failing case but without java.lang.Iterable.
+  def f2[M](xs: scala.collection.immutable.Seq[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    xs.collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // 2b. Variant: `.map` instead of `.collect` over the same pure-Scala input.
+  def f2b[M](xs: scala.collection.immutable.Seq[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    xs.map {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // 2c. Variant: List instead of Seq.
+  def f2c[M](xs: List[Container[Any, ? <: M]])
+      : List[Container[Any, M]] =
+    xs.collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // ---- 3. Generic helper that stays pure-Scala does not skolemize ----
+  def idSeq[T](it: Iterable[T]): scala.collection.immutable.Seq[T] = ???
+
+  def f3[M](xs: List[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    idSeq(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // ---- 4. Documented workaround for the akka-style failure -----------
+  // Until tests/neg/i16018.scala flips to pos, user code must widen the
+  // narrow-pattern branch explicitly. Guarding this shape ensures the
+  // workaround itself does not regress.
+  def seqOf[T](it: java.lang.Iterable[T]): scala.collection.immutable.Seq[T] = ???
+
+  def f4_workaround_iterable[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => (g: Container[Any, M])
+      case other                              => other
+    }
+
+  def f4_workaround_list[M](xs: java.util.List[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => (g: Container[Any, M])
+      case other                              => other
+    }
+
+  // 4b. Workaround via .asInstanceOf is equally valid.
+  def f4_asInstanceOf[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g.asInstanceOf[Container[Any, M]]
+      case other                              => other
+    }