Do not emit a SYNCHRONIZED method for Outer.this.synchronized calls (#26998)

Reported by @natsukagami offline. Regression from #26697

## Have you relied on LLM-based tools in this contribution?

No

## How was the solution tested?

New automated tests (including the issue's reproducer, if applicable)

Author: SolalPirelli

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

@@ -17,7 +17,10 @@ class SimplifySynchronized extends MiniPhase:
   override def transformDefDef(tree: DefDef)(using Context): Tree = {
     @tailrec
     def extractSynchronized(rhs: Tree): Option[Tree] = rhs match
-      case Apply(TypeApply(Ident(nme.synchronized_) | Select(This(_), nme.synchronized_), _), synchronizedBody :: Nil) =>
+      case Apply(TypeApply(Ident(nme.synchronized_), _), synchronizedBody :: Nil) =>
+        Some(synchronizedBody)
+      // `This(X)` means `this` inside `X` but `X.this` inside a nested class of `X`!
+      case Apply(TypeApply(Select(t: This, nme.synchronized_), _), synchronizedBody :: Nil) if t.tpe == tree.symbol.owner.thisType =>
         Some(synchronizedBody)
       case Block(Nil, expr) =>
         extractSynchronized(expr)

compiler/test/dotc/scoverage-ignore.excludelist

@@ -43,3 +43,4 @@ spurious-overload.scala
 tailrec-synchronized.scala
 tailrec.scala
 traitParams.scala
+outer-synchronized.scala

tests/run/outer-synchronized.check

@@ -0,0 +1,3 @@
+32
+32
+0

tests/run/outer-synchronized.scala

@@ -0,0 +1,24 @@
+// scalajs: --skip
+// (JVM-only reflection-based test)
+
+class Outer:
+  var x = 0
+  class Inner:
+    def f(): Unit = Outer.this.synchronized { x += 1 }
+  def own(): Unit = this.synchronized { x += 1 }
+  def ownImplicit(): Unit = synchronized { x += 1 }
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val o = new Outer()
+    val i = new o.Inner()
+
+    val om = o.getClass.getDeclaredMethods.find(_.getName == "own").get
+    println(om.getModifiers & java.lang.reflect.Modifier.SYNCHRONIZED)
+
+    val om2 = o.getClass.getDeclaredMethods.find(_.getName == "ownImplicit").get
+    println(om2.getModifiers & java.lang.reflect.Modifier.SYNCHRONIZED)
+
+    val fm = i.getClass.getDeclaredMethods.find(_.getName == "f").get
+    println(fm.getModifiers & java.lang.reflect.Modifier.SYNCHRONIZED)
+