Set the inlining phase in the Context used for checking macro trees (#20087)

Fixes #17009 
The problem here was with the sub typing check for `line.split(" ").nn`,
which needed to confirm that:

```scala
(?2 : Array[String]) & Array[String]  <:  (?1 : Array[String]) & Array[String]
```
`TypeComparer` would eventually try to compare two skolem types:
```scala
(?2 : Array[String]) <: (?1 : Array[String])
```
The behavior of `TypeComparer` differs here when executed during the
typer phase, where it always returns false for two skolem types, without
checking the sub typing further. This makes sense for Typer, but not so
much for the macro checks, which for `transparent inline`s end up being
executed during Typer. I think the best solution here is to artificially
change the phase in the checkingContext, so the checks done for
transparent and non-transparent macros are the same.

Author: nicolasstucki

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

@@ -837,9 +837,19 @@ object TreeChecker {
 
   def checkMacroGeneratedTree(original: tpd.Tree, expansion: tpd.Tree)(using Context): Unit =
     if ctx.settings.XcheckMacros.value then
+      // We want make sure that transparent inline macros are checked in the same way that
+      // non transparent macros are, so we try to prepare a context which would make
+      // the checks behave the same way for both types of macros.
+      // 
+      // E.g. Different instances of skolem types are by definition not able to be a subtype of
+      // one another, however in practice this is only upheld during typer phase, and we do not want
+      // it to be upheld during this check.
+      // See issue: #17009
       val checkingCtx = ctx
         .fresh
         .setReporter(new ThrowingReporter(ctx.reporter))
+        .setPhase(ctx.base.inliningPhase)
+
       val phases = ctx.base.allPhases.toList
       val treeChecker = new LocalChecker(previousPhases(phases))
 

tests/pos-macros/i17009/Macro_1.scala

@@ -0,0 +1,6 @@
+import scala.quoted._
+
+object Macro {
+  transparent inline def transform[T](inline expr: T): T = ${ transformImpl[T]('expr) }
+  def transformImpl[T: Type](f: Expr[T])(using Quotes): Expr[T] = f
+}

tests/pos-macros/i17009/Main_2.scala

@@ -0,0 +1,6 @@
+def processLine(line: String): Unit = {
+  Macro.transform {
+    line.split(" ").nn
+    ???
+  }
+}