Pretty-print lambdas (#21846)

Before:

```scala
[[syntax trees at end of                     typer]] // tests/printing/lambdas.scala
package <empty> {
  final lazy module val Main: Main = new Main()
  final module class Main() extends Object() { this: Main.type =>
    val f1: Int => Int =
      {
        def $anonfun(x: Int): Int = x.+(1)
        closure($anonfun)
      }
    val f2: (Int, Int) => Int =
      {
        def $anonfun(x: Int, y: Int): Int = x.+(y)
        closure($anonfun)
      }
    val f3: Int => Int => Int =
      {
        def $anonfun(x: Int): Int => Int =
          {
            def $anonfun(y: Int): Int = x.+(y)
            closure($anonfun)
          }
        closure($anonfun)
      }
    val f4: [T] => (x: Int) => Int =
      {
        def $anonfun[T >: Nothing <: Any](x: Int): Int = x.+(1)
        closure($anonfun)
      }
    val f5: [T] => (x: Int) => Int => Int =
      {
        def $anonfun[T >: Nothing <: Any](x: Int): Int => Int =
          {
            def $anonfun(y: Int): Int = x.+(y)
            closure($anonfun)
          }
        closure($anonfun)
      }
    val f6: Int => Int =
      {
        def $anonfun(x: Int): Int =
          {
            val x2: Int = x.+(1)
            x2.+(1)
          }
        closure($anonfun)
      }
    def f7(x: Int): Int = x.+(1)
    val f8: Int => Int =
      {
        def $anonfun(x: Int): Int = Main.f7(x)
        closure($anonfun)
      }
    val l: List[Int] = List.apply[Int]([1,2,3 : Int]*)
    Main.l.map[Int](
      {
        def $anonfun(_$1: Int): Int = _$1.+(1)
        closure($anonfun)
      }
    )
    Main.l.map[Int](
      {
        def $anonfun(x: Int): Int = x.+(1)
        closure($anonfun)
      }
    )
    Main.l.map[Int](
      {
        def $anonfun(x: Int): Int =
          {
            val x2: Int = x.+(1)
            x2.+(1)
          }
        closure($anonfun)
      }
    )
    Main.l.map[Int](
      {
        def $anonfun(x: Int): Int = Main.f7(x)
        closure($anonfun)
      }
    )
  }
}
```

After:
```scala
[[syntax trees at end of                     typer]] // tests/printing/lambdas.scala
package <empty> {
  final lazy module val Main: Main = new Main()
  final module class Main() extends Object() { this: Main.type =>
    val f1: Int => Int = (x: Int) => x.+(1)
    val f2: (Int, Int) => Int = (x: Int, y: Int) => x.+(y)
    val f3: Int => Int => Int = (x: Int) => (y: Int) => x.+(y)
    val f4: [T] => (x: Int) => Int = [T >: Nothing <: Any] => (x: Int) => x.+(1)
    val f5: [T] => (x: Int) => Int => Int = [T >: Nothing <: Any] => (x: Int)
       => (y: Int) => x.+(y)
    val f6: Int => Int = (x: Int) =>
      {
        val x2: Int = x.+(1)
        x2.+(1)
      }
    def f7(x: Int): Int = x.+(1)
    val f8: Int => Int = (x: Int) => Main.f7(x)
    val l: List[Int] = List.apply[Int]([1,2,3 : Int]*)
    Main.l.map[Int]((_$1: Int) => _$1.+(1))
    Main.l.map[Int]((x: Int) => x.+(1))
    Main.l.map[Int]((x: Int) =>
      {
        val x2: Int = x.+(1)
        x2.+(1)
      }
    )
    Main.l.map[Int]((x: Int) => Main.f7(x))
  }
}
```

The ugly thing can still be displayed with `-Yprint-debug`.

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -17,6 +17,7 @@ import Denotations.*
 import SymDenotations.*
 import StdNames.{nme, tpnme}
 import ast.{Trees, tpd, untpd}
+import tpd.closureDef
 import typer.{Implicits, Namer, Applications}
 import typer.ProtoTypes.*
 import Trees.*
@@ -510,6 +511,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(name) ~ (if name.isTermName && arg.isType then " : " else " = ") ~ toText(arg)
       case Assign(lhs, rhs) =>
         changePrec(GlobalPrec) { toTextLocal(lhs) ~ " = " ~ toText(rhs) }
+      case closureDef(meth) if !printDebug =>
+        withEnclosingDef(meth):
+          meth.paramss.map(paramsText).foldRight(toText(meth.rhs))(_ ~ " => " ~ _)
       case block: Block =>
         blockToText(block)
       case If(cond, thenp, elsep) =>

tests/printing/annot-19846b.check

@@ -7,27 +7,13 @@ package <empty> {
   final lazy module val Test: Test = new Test()
   final module class Test() extends Object() { this: Test.type =>
     val y: Int = ???
-    val z:
-      Int @lambdaAnnot(
-        {
-          def $anonfun(): Int = Test.y
-          closure($anonfun)
-        }
-      )
-     = f(Test.y)
+    val z: Int @lambdaAnnot(() => Test.y) = f(Test.y)
   }
   final lazy module val annot-19846b$package: annot-19846b$package =
     new annot-19846b$package()
   final module class annot-19846b$package() extends Object() {
     this: annot-19846b$package.type =>
-    def f(x: Int):
-      Int @lambdaAnnot(
-        {
-          def $anonfun(): Int = x
-          closure($anonfun)
-        }
-      )
-     = x
+    def f(x: Int): Int @lambdaAnnot(() => x) = x
   }
 }
 

tests/printing/lambdas.check

@@ -0,0 +1,30 @@
+[[syntax trees at end of                     typer]] // tests/printing/lambdas.scala
+package <empty> {
+  final lazy module val Main: Main = new Main()
+  final module class Main() extends Object() { this: Main.type =>
+    val f1: Int => Int = (x: Int) => x.+(1)
+    val f2: (Int, Int) => Int = (x: Int, y: Int) => x.+(y)
+    val f3: Int => Int => Int = (x: Int) => (y: Int) => x.+(y)
+    val f4: [T] => (x: Int) => Int = [T >: Nothing <: Any] => (x: Int) => x.+(1)
+    val f5: [T] => (x: Int) => Int => Int = [T >: Nothing <: Any] => (x: Int)
+       => (y: Int) => x.+(y)
+    val f6: Int => Int = (x: Int) =>
+      {
+        val x2: Int = x.+(1)
+        x2.+(1)
+      }
+    def f7(x: Int): Int = x.+(1)
+    val f8: Int => Int = (x: Int) => Main.f7(x)
+    val l: List[Int] = List.apply[Int]([1,2,3 : Int]*)
+    Main.l.map[Int]((_$1: Int) => _$1.+(1))
+    Main.l.map[Int]((x: Int) => x.+(1))
+    Main.l.map[Int]((x: Int) =>
+      {
+        val x2: Int = x.+(1)
+        x2.+(1)
+      }
+    )
+    Main.l.map[Int]((x: Int) => Main.f7(x))
+  }
+}
+

tests/printing/lambdas.scala

@@ -0,0 +1,14 @@
+object Main:
+  val f1 = (x: Int) => x + 1
+  val f2 = (x: Int, y: Int) => x + y
+  val f3 = (x: Int) => (y: Int) => x + y
+  val f4 = [T] => (x: Int) => x + 1
+  val f5 = [T] => (x: Int) => (y: Int) => x + y
+  val f6 = (x: Int) => { val x2 = x + 1; x2 + 1 }
+  def f7(x: Int) = x + 1
+  val f8 = f7
+  val l = List(1,2,3)
+  l.map(_ + 1)
+  l.map(x => x + 1)
+  l.map(x => { val x2 = x + 1; x2 + 1 })
+  l.map(f7)