Add some way to expand macros in Quotes in metaprogramming API

[rssh]

It would be good to have some way to expand macroses from metaprogramming API.

Something like:

 object X {
       inline def  incr(x:Int): Int = x+1
 }

 '{  X.incr(1)  }.expandMacroses()    //  expect to see  something like  1 + 1

Usecase is passing 'configuration depends from type' to macroses. I.e. I have one big macro which accepts some types, and inside these macros different types can have different additional compile-time operations, which I want to interpret inside the scope of 'big macros'.
[More concrete example: memorizing in IO have type IO[IO[T]]; in monix: Task[T], in Future - none (it's memorized by default), so for uniform handling of effect memorization I need or write 'if' in macros for concrete libs (which I want to avoid) or define via implicit search some sort of macro-code for each type, which should be substituted inside my big 'async' macro. With this feature implemented this can be just a macro definition.]

[LPTK]

I think it should work with a transparent inline def. Normal inline macros are no longer expanded during type checking.

[rssh]

Currently is no way to expand macro (event transient inline) programmatically from quotation.

Here is a code:
X.scala

package x

import scala.quoted._

def p(x: Int):Int = ???

object Incr:

  transparent inline def op(x:Int):Int =
    p(x + 1)

object GenX:

 inline def transform(inline x:Int, viaMacro: Boolean):Int = ${
    transformImpl('x, 'viaMacro)
 }

 def transformImpl(x:Expr[Int], viaMacro: Expr[Boolean])(using qctx: Quotes):Expr[Int] =
    import qctx.reflect._
    val r1 = if (viaMacro.valueOrError) then {
              '{ Incr.op($x) }.asExprOf[Int]
             } else {
              '{ p($x+1) }.asExprOf[Int]
             }
    println(s"r1=${r1.show}")
    val noP = new TreeMap() {
        override def transformTerm(tree:Term)(owner: Symbol): Term =
            tree match
              case Apply(Ident("p"),List(y)) =>
                      '{ val tmp=${y.asExprOf[Int]}; println(s"p:$tmp"); tmp }.asTerm
              case _ => super.transformTerm(tree)(owner)
    }
    val r2 = noP.transformTerm(r1.asTerm)(Symbol.spliceOwner).asExprOf[Int]
    println(s"r2=${r2.show}")
    r2

and Main.scala:

package x


object Main {


 def main(args:Array[String]):Unit =
   val a = GenX.transform(1, false)
   val b = GenX.transform(2, true)

}

when we compile/run this we receive:

r1=x.X$package.p(1.+(1))
r2={
  val tmp: scala.Int = 1.+(1)
  scala.Predef.println(_root_.scala.StringContext.apply("p:", "").s(tmp))

  (tmp: scala.Int)
}
r1=x.Incr.op(2)
r2=x.Incr.op(2)
[info] running x.Main 
p:2
[error] (run-main-0) scala.NotImplementedError: an implementation is missing
[error] scala.NotImplementedError: an implementation is missing
[error] 	at scala.Predef$.$qmark$qmark$qmark(Predef.scala:345)
[error] 	at x.X$package$.p(X.scala:5)
[error] 	at x.Main$.main(Main.scala:9)
[error] 	at x.Main.main(Main.scala)
[error] 	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
[error] 	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:64)
[error] 	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
[error] 	at java.base/java.lang.reflect.Method.invoke(Method.java:564)
[error] stack trace is suppressed; run last Compile / bgRun for the full output
[error] Nonzero exit code: 1
[error] (Compile / run) Nonzero exit code: 1

I.e. as we see, when we use macro in quotation, it's not expanded. r1 in transformImpl is Incr.op(1)
It's why I propose here to add something like expandMacro() to Expr.

[rssh]

Aga, as I understand the @LPTK comment, the question: should we allow only transient inline macroses here?

I.e.:

 Expr.expandTransientInlineMacroses()

vs

 Expr.expandMacroses(transientOnly: Boolean)

Technically, any variant is ok (because it will allow passing behavior to macroses). Generic expand macroses is slightly better (as more general), but if we can't run compiler pass on a tree, living with expandTransientInline() only is possible.