Forbid term params for inline traits

This decision, approved by M. Odersky and N. Stucki, comes from the fact that traits cannot call the constructors of other traits.
This creates a problem when inlining inner traits, because they need to extend their original counterpart. However, since it cannot
pass arguments, the extension would need to be generated when inlining, which adds the need for param bindings.

Example:
```
inline trait A:
  trait Inner(x: Int)
  /*
   * replaced by:
   *
   * trait Inner$trait(x: Int)
   * type Inner <: Inner$trait
   */
end A

class B extends A:
  /*
   * generated:
   *
   * trait Inner(x: Int) extends Inner$trait  // missing term x
   */
end B

val b = B()
class C extends B.Inner(1)  // invalid: must declare extension of Inner$trait explicitly
```

Author: timotheeandres

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2688,6 +2688,18 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           )
         )
         val membersToInline = body1.filter(member => Inlines.isInlineableFromInlineTrait(cls, member))
+        membersToInline.foreach {
+          case tdef: TypeDef if tdef.symbol.isClass =>
+            def rec(paramss: List[List[Symbol]]): Unit = paramss match {
+              case (param :: _) :: _ if param.isTerm =>
+                report.error(em"Implementation restriction: inline traits cannot have term parameters", param.srcPos)
+              case _ :: paramss =>
+                rec(paramss)
+              case _ =>
+            }
+            rec(tdef.symbol.primaryConstructor.paramSymss)
+          case _ =>
+        }
         val wrappedMembersToInline = Block(membersToInline, unitLiteral).withSpan(cdef.span)
         PrepareInlineable.registerInlineInfo(cls, wrappedMembersToInline)
 

tests/neg/inline-trait-body-trait-parameter.scala

@@ -0,0 +1,7 @@
+inline trait A[T]:
+  trait InnerAType[T >: Int <: AnyVal]
+  trait InnerATypes[T <: AnyVal, U <: T]
+  trait InnerATerm(i: Int)  // error
+  trait InnerATerms(i: Int, j: Double)  // error
+  trait InnerATermsCurried(i: Int, j: Double)(k: String)  // error
+  trait InnerAAllCurried[T, U](i: T, j: U)(k: (T, U))  // error