Treat erased members like lazy ones

Partially address TODO on erased members by treating them like lazy values: they
do not exist at runtime, and their initialization might fail, but they're
realizable if their type is.

I do not treat erased members as _final_ lazy ones because erased definitions
are not automatically final, and it's not 100% obvious they should be (after
discussion with Nicholas Stucki). Current situation:

If `U <: T`, the current rules allow the following override

```scala
trait A {
  erased def foo: T = ...
}
trait B extends A {
  erased def foo: U = ...
}
```

And just like lazy values, `U` might be unrealizable even when `T` is, so it's
unsafe to treat `(a: A).foo` as realizable.

The above code might be used (questionably) through
```scala
def takeErased(erased a: T): Any
def takeBetterErased(erased a: U): String
def f(a: A) = a match {
  case b: B =>
    takeBetterErased(b.foo)
  case _ =>
    takeErased(a.foo)
}
```
It's very unclear whether that's desirable.

Alternatively, concrete erased definitions might be made automatically final,
and that would be picked up by `isEffectivelyFinal` without further changes.

Author: Blaisorblade

compiler/src/dotty/tools/dotc/core/CheckRealizable.scala

@@ -88,8 +88,8 @@ class CheckRealizable(implicit ctx: Context) {
           // Reject fields that are mutable, by-name, and similar.
           if (!sym.isStableMember)
             patchRealizability(NotStable)
-            // 3. If the symbol isn't "lazy" and its prefix is realizable
-          else if (!isLateInitialized(sym)) {
+            // 3. If the symbol isn't "lazy" or erased, and its prefix is realizable
+          else if (!isLateInitialized(sym) && !sym.is(Erased)) {
             // The symbol itself is stable, cache this information:
             sym.setFlag(Stable)
             // Realizability now depends on the prefix:

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -475,9 +475,7 @@ object Flags {
 
   /** A value that's unstable unless complemented with a Stable flag */
   final val UnstableValue =
-    Mutable | Method | Erased
-      // TODO: Erased should be treated as stable just like final lazy is.
-      // Otherwise the usefulness of Erased is very much reduced.
+    Mutable | Method
 
   /** Flags that express the variance of a type parameter. */
   final val VarianceFlags = Covariant | Contravariant