Implement Reflection API directly

Revert to the original design with abstract modules that are implemented directly.
We had to move the implementations to the compiler interface with one of the iterations of extension methods.
The current extension methods are again compatible with this design.

CompilerInterface is kept for the internal methods that are only available in the stdlib.

* Now Reflection contains the full user-facing API
* CompilerInterface only contains internal methods used in the stdlib
* tasty.refelct.Types was merged into Reflection
* QuoteContextImpl implements every member directly
* All members of tasty are lazily initialized using object
* Fix defn.NullClass
* Fix typo in Flags.Accessor
* Rename Scala2X to Scala2x to follow dotty conventions

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -186,6 +186,7 @@ class TailRec extends MiniPhase {
           def tailArgOrPureExpr(stat: Tree): Boolean = stat match {
             case stat: ValDef if stat.name.is(TailTempName) || !stat.symbol.is(Mutable) => tailArgOrPureExpr(stat.rhs)
             case Assign(lhs: Ident, rhs) if lhs.symbol.name.is(TailLocalName) => tailArgOrPureExpr(rhs)
+            case Assign(lhs: Ident, rhs: Ident) if lhs.symbol == rhs.symbol => true
             case stat: Ident if stat.symbol.name.is(TailLocalName) => true
             case _ => tpd.isPureExpr(stat)
           }

compiler/src/dotty/tools/dotc/quoted/reflect/ReflectionCompilerInterface.scala

@@ -59,10 +59,8 @@ object Liftable {
   /** Default liftable for Class[T] */
   given ClassLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
     def toExpr(x: Class[T]) = {
-      val qctx1 = scala.internal.tasty.CompilerInterface.quoteContextWithCompilerInterface(qctx)
-      import qctx1.tasty._
-      val tpe = qctx1.tasty.Type_ofErasedClass(x)
-      Ref(defn.Predef_classOf).appliedToType(tpe).seal.asInstanceOf[Expr[Class[T]]]
+      import qctx.tasty._
+      Ref(defn.Predef_classOf).appliedToType(Type.typeConstructorOf(x)).seal.asInstanceOf[Expr[Class[T]]]
     }
   }