New Syntax for Capture Variables and Explicit Capture Polymorphism v3 (#23063)

Closes #22490
Builds on #22725
Supersedes #22902

This syntax for capture variables and members caters to the view that
"they are another kind", and most conventions we know from higher-kinded
type parameters carry over.

A postfix `^` (analogous to `[_]`) indicates that a type
parameter/member ranges over capture sets
```scala
def sayHi[C^](l: Logger^{C}) = l.log("hello world")

trait LList[T, C^]:
  type D^ >: C // or equivalently >: {C}
  val node: Ref[T^{D}]^
```

These variables can be bounded by capture-set literals:
```scala
trait Foo:
  type C^ 
  type D^ >: {logger} <: {logger, async, this.C}
  type E^ : Monad // error, context bounds are forbidden
```

Just as with higher-kinded type parameters, the kind is "contagious",
and we can often avoid the hat if the bounds are concrete capture sets
or other capture variables:

```scala
trait Foo:
  type C >: {} <: {cap}     // no hat needed
  type D >: C               // dito
  type E = {x,y,z}          // dito
  type F >: Object <: {cap} // error, ill-kinded
```

Capture variables will be erased if capture checking is turned off. In
non-capture-checked code, they are essentially type variables within the
interval `>: caps.CapSet <: caps.CapSet`. With capture checking turned
on and without explicit bounds, the interval corresponds to `>:
caps.CapSet^{} <: caps.CapSet^{caps.cap}`.

## Tasks
- [x] Bullet-proof the "can avoid the hat" for binders scheme.
- [x] Grammar doc.
- [x] Update language reference.
- [x] Port new tests.
- [x] Clarify when and where to produce attachments.
- [x] Forbid nonsense intervals mixing capture sets and types.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -642,7 +642,7 @@ object desugar {
       .withMods(mods & (GivenOrImplicit | Erased | hasDefault | Tracked) | Param)
   }
 
-  /** Desugar type def (not param): Under x.moduliity this can expand
+  /** Desugar type def (not param): Under x.modularity this can expand
    *  context bounds, which are expanded to evidence ValDefs. These will
    *  ultimately map to deferred givens.
    */

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -34,6 +34,9 @@ object Trees {
 
   val SyntheticUnit: Property.StickyKey[Unit] = Property.StickyKey()
 
+  /** Property key for marking capture-set variables and members */
+  val CaptureVar: Property.StickyKey[Unit] = Property.StickyKey()
+
   /** Trees take a parameter indicating what the type of their `tpe` field
    *  is. Two choices: `Type` or `Untyped`.
    *  Untyped trees have type `Tree[Untyped]`.