Fix #8001: Erase polymorphic value classes like Scala 2

[smarter]

Previously given:

class Poly[A](val value: A) extends AnyVal

We always erased Poly[X] to Object, no matter the value X, because
the erasure was the erased underlying type as seen from its definition,
and not as seen from the current prefix. But it turns out that in Scala
2, Foo[Int] will be erased to Integer instead (it would have made
more sense to use int but I suspect this is more accidental than
designed).

To be binary-compatible with Scala 2 and to support the same kind of
overloads we need to replicate its behavior, more precisely the rules I
was able to reverse-engineer are:

• Given class Foo[A](x: A) extends AnyVal, Foo[X] should erase like
  X, except if its a primitive in which case it erases to the boxed
  version of this primitive.
• Given class Bar[A](x: Array[A]) extends AnyVal, Bar[X] will be
  erased like Array[A] as seen from its definition site, no matter
  the X (same if A is bounded).

I was able to adapt our implementation of value class erasure to these
new rules without too much refactoring through one compromise: a value
class can no longer wrap another value class. This was never supported
by Scala 2 so we can afford to not support it either.

[bishabosha]

it probably doesn't add much new as a test case but i noticed this erases differently on Scala 2 vs Dotty

object Values {
  def reify[I <: Int with Singleton](implicit I: ValueOf[I]): I = valueOf[I]
}

[smarter]

@bishabosha erasure of intersection types is something I'll address in another PR.

[bishabosha]

@bishabosha erasure of intersection types is something I'll address in another PR.

I've removed the singleton bound and its the same result,

object Values {
  //public <I extends java.lang.Object> I reify(I);
  //    descriptor: (Ljava/lang/Object;)I
  def reify[I <: Int](implicit I: ValueOf[I]): I = valueOf[I]
}

[smarter]

OK, that should be covered by class Poly in the tests.