Disallow recursive lower bounds in constraints

These can lead to deep subtype errors, this also fixes #8976 but see
also the next commit which fixes the underlying soundness issue.

Author: smarter

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -87,6 +87,10 @@ trait ConstraintHandling[AbstractContext] {
 
   protected def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean)(using AbstractContext): Boolean =
     if !constraint.contains(param) then true
+    else if !isUpper && param.occursIn(bound)
+      // We don't allow recursive lower bounds when defining a type,
+      // so we shouldn't allow them as constraints either.
+      false
     else
       val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
       val equalBounds = (if isUpper then lo else hi) eq bound

tests/neg/i8976.scala

@@ -0,0 +1,5 @@
+trait Cons[X, Y]
+
+def solve[X, Y](using Cons[X, Y] =:= Cons[1, Cons[2, Y]]) = ()
+
+@main def main = solve // error

tests/neg/recursive-lower-constraint.scala

@@ -0,0 +1,7 @@
+class Foo[F <: Foo[F]]
+class Bar extends Foo[Bar]
+
+class A {
+  def foo[T <: Foo[T], U >: Foo[T] <: T](x: T): T = x
+  foo(new Bar) // error
+}