Implement applied constructor types

[KacperFKorban]

closes #22542

Introduce new syntax to make classes with tracked parameters
easier to use. The new syntax is essentially the ability to use an application
of a class constructor as a type, we call such types applied constructor types.

With this new feature the following example compiles correctly and the type in
the comment is the resulting type of the applied constructor types.

import scala.language.experimental.modularity

class C(tracked val v: Any)

val c: C(42) /* C { val v: 42 } */ = C(42)

Syntax change

SimpleType        ::=  SimpleLiteral
                    |  ‘?’ TypeBounds
---                 |  SimpleType1
+++                 |  SimpleType1 {ParArgumentExprs}

A SimpleType can now optionally be followed by ParArgumentExprs.

[KacperFKorban]

The CI failure seems to be the same as on main and looks unrelated.

[mbovel]

I've noticed during your presentation that it also works for using parameters:

import language.experimental.modularity

class Box[T](using tracked val value: Int)

def main =
  given Int = 42
  val b: Box() = Box()

after typer:

def main: Unit =
  final lazy given val given_Int: Int = 42
  val b: Box[Any]{val value: (given_Int : Int)} = new Box[Any](given_Int)()

[odersky]

I did not understand the condition. I guess you want to exclude constructors with no value parameters, but I am not clear why the condition preciseTp frozen_=:= classTp is equivalent to that.

[KacperFKorban]

This checks a slightly different condition. This also triggers for classes with non-tracked parameters.
e.g.
In the following case, the type of UnspecificBox and UnspecificBox(4) is the same.

class UnspecificBox(val v: Any)
val v1: UnspecificBox(4) = UnspecificBox(4) // warn

[odersky]

The new case should not be added here. This is about the hottest code that exists in the compiler. We need to keep it as small as possible. Instead I would suggest to add the distinction to Applications.scala following line 1283:

val app = tree.fun match
  case Select(New(tpt), _) 
  if ctx.mode.is(Mode.Type) && Feature.enabled(modularity && !ctx.isAfterTyper => 
    typedAppliedConstructorType(tpt, tree.args)
  case untpd.TypeApply(_: untpd.SplicePattern, _) if Feature.quotedPatternsWithPolymorphicFunctionsEnabled =>
    ...

[KacperFKorban]

Ok, I moved it to Applications.scala. Though I added a nested case (that defaults to realApply) for applied constructors, since we match on untpd.methPart(tree.fun), instead of just tree.fun

[odersky]

LGTM. Needs a conflict resolution with ErrorMessageID.