Fix inline export forwarder generation regression (#23126)

To explain what was happening and what the issue was:
Minimalisation:
```scala
import scala.quoted.*

package jam {
  trait JamCoreDsl {
    implicit inline def defaultJamConfig: this.JamConfig =
      new JamConfig(brewRecRegex = ".*")
    class JamConfig(val brewRecRegex: String)
    inline def brew(implicit inline config: JamConfig): Unit = ???
  }
  private object internal extends JamCoreDsl
  export internal._
}

object test {
  jam.brew
}
```
would fail retyping in the inlining phase.

During typer, because we were exporting contents of `Internal`, the
compiler created forwarders (in Namer.addForwarder) for methods chosen
in the export. The forwarders looked like this:
```scala
      final implicit inline def defaultJamConfig: jam.internal.JamConfig =
        jam.Internal.defaultJamConfig
      final inline def brew(implicit inline config: jam.internal.JamConfig):
        Unit = jam.Internal.brew(config)
```
While creating them, the compiler would also try to type them. Because
those forwarder methods were inline, the compiler would call
PrepareInlineable.makeInlineable on them. That method would transform
rhs of the forwarder method, to make sure it does not reference any
private methods/objects. Since `Internal` is private (and referenced in
both exported methods, notably in brew with rhs
jam.Internal.brew(config)), an accessor inline$Internal was created, and
the forwarder method contents remapped.

Then, during inlining in the inline phase, the ReTyper was not able to
type `jam.inline$internal.brew(config)`, with `jam.inline$internal.brew`
being typed as `Nothing => Unit` (likely having remapped the argument to
Nothing in an asSeenFrom, after deciding that the prefix is not stable).

But none of this happened when I created those forwarders and accessors
manually. After some digging it turned out that the `inline$internal`
accessor method was typed as `TypeRef(ThisType(TypeRef(NoPrefix,module
class jam)),module class internal$))`, but the manually created one was
a `TermRef(ThisType(TypeRef(NoPrefix,module class jam)), object
Internal)`. It seems like the first one has an unstable prefix, so its
denotation is not typed correctly, leading to the issue.
Fixes #22593

Author: hamzaremmal

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

@@ -141,8 +141,13 @@ abstract class AccessProxies {
         if accessorClass.is(Package) then
           accessorClass = ctx.owner.topLevelClass
         val accessorName = accessorNameOf(accessed.name, accessorClass)
+        val mappedInfo = accessed.info match
+          // TypeRef pointing to module class seems to not be stable, so we remap that to a TermRef
+          // see test i22593.scala (and issue #i22593)
+          case tref @ TypeRef(prefix, _) if tref.symbol.is(Module) => TermRef(prefix, tref.symbol.companionModule)
+          case other => other
         val accessorInfo =
-          accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
+          mappedInfo.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
         val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)
         rewire(reference, accessor)
       }

tests/pos/i22593a.scala

@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+package jam {
+  trait JamCoreDsl {
+    implicit inline def defaultJamConfig: this.JamConfig =
+      new JamConfig(brewRecRegex = ".*")
+    class JamConfig(val brewRecRegex: String)
+    inline def brew(implicit inline config: JamConfig): Unit = ???
+  }
+  private object internal extends JamCoreDsl
+  export internal._
+}
+
+object test {
+  jam.brew
+}

tests/pos/i22593b/Main.scala

@@ -0,0 +1,27 @@
+import scala.quoted.*
+
+package jam {
+    trait JamCoreDsl {
+        implicit inline def defaultJamConfig: this.JamConfig =
+            new JamConfig(brewRecRegex = ".*")
+        class JamConfig(val brewRecRegex: String)
+        inline def brew(implicit inline config: JamConfig): Unit = ${ brewImpl() }
+    }
+    private object internal extends JamCoreDsl
+    export internal._
+
+    def brewImpl(using q: Quotes)(): Expr[Unit] = {
+        findSelf
+        '{()}
+    }
+
+    private def findSelf(using q: Quotes): Unit = {
+        import q.reflect.*
+        def rec(s: Symbol): Option[Symbol] = s.maybeOwner match {
+            case o if o.isNoSymbol => None
+            case o if o.isClassDef => Option(o)
+            case o => rec(o)
+        }
+        rec(Symbol.spliceOwner)
+    }
+}

tests/pos/i22593b/Test.scala

@@ -0,0 +1,3 @@
+object CoreSpec  {
+  jam.brew
+}