Handle TypeError during Erasure phase

Fixes #20491

Wrap the `transform` method in Erasure with a try-catch to handle `TypeError` (including `MissingType`).
These errors can occur during TypeErasure when accessing types from dependencies compiled with newer JDK versions that use APIs unavailable in the current runtime.

For example, when a library compiled with JDK 21 (using
`java.util.concurrent.StructuredTaskScope`) is used in a project running on JDK 17, the compiler currently crashes with an unhandled `MissingType` exception during the Erasure phase instead of reporting an error.

`MissingType` is thrown from `TypeErasure.sigName` or `checkedSuperType`, which are called from `TypeErasure.eraseXXX`.
These errors are usually caught by `Typer.handleTypeError` or `TreePickler.pickleType`, but those handlers do not cover exceptions thrown during the Erasure. (It seems that during typer, the compiler trusts the information from the classfile or tasty without verifying that all referenced types actually exist on the classpath).

This commit encloses `Erasure.transform` with a try-catch to intercept the `TypeError` and call `report.error`.

We can test the change manually:

```
.
|-- cp
|   `-- ox
|       `-- Ox.class
`-- test.scala
```

`Ox.class` is compiled from:

```scala
//> using jvm 21
package ox
import java.util.concurrent.StructuredTaskScope
trait Ox {
  def scope: StructuredTaskScope[Any]
}
```

and `test.scala`:

```scala
//> using jvm 17
given ox.Ox = ???
```

`$ scala-cli compile test.scala -S 3.8.1-RC1-bin-SNAPSHOT --extra-jars ./cp`

now it should compile fails, instead of crash.

Author: tanishiking

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -20,6 +20,7 @@ import core.Decorators.*
 import core.Constants.*
 import core.Definitions.*
 import core.Annotations.BodyAnnotation
+import core.TypeError
 import typer.NoChecking
 import inlines.Inlines
 import typer.ProtoTypes.*
@@ -49,7 +50,7 @@ class Erasure extends Phase with DenotTransformer {
   override def changesMembers: Boolean = true // the phase adds bridges
   override def changesParents: Boolean = true // the phase drops Any
 
-  def transform(ref: SingleDenotation)(using Context): SingleDenotation = ref match {
+  def transform(ref: SingleDenotation)(using Context): SingleDenotation = try ref match {
     case ref: SymDenotation =>
       def isCompacted(symd: SymDenotation) =
         symd.isAnonymousFunction && {
@@ -130,7 +131,10 @@ class Erasure extends Phase with DenotTransformer {
         ref.symbol, transformInfo(ref.symbol, ref.symbol.info), currentStablePeriod, ref.prefix)
     case _ =>
       ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.symbol, ref.symbol.info))
-  }
+  } catch case ex: TypeError =>
+    // Handle missing types from dependencies (e.g., JDK version mismatch)
+    report.error(ex.toMessage, ref.symbol.srcPos)
+    ref  // Keep old denotation on error
 
   private val eraser = new Erasure.Typer(this)