Fix provablyDisjoint handling of HK types

If refineUsingParent/instantiateToSubType is passed a HK then it's
not possible to instantiate a class to that type (at the moment and
perhaps ever).  So it's important we guard against that.

This came up while trying to see if Mark[?] and Foo[Int] (from
pos/i19031.ci-reg1.scala) are provably disjoint - which they should be
reported not to be.  Because they're not applied types of the same type
constructor we end up trying to prove that HK type Mark is disjoint from
HK type Foo.  Because we don't know how to instantiate Foo's subclasses
(e.g Bar2) such that it's a subtype of higher-kinded type "Mark", we end
up discarding all of Foo's subclasses, which implies that Foo & Mark is
uninhabited, thus they are provably disjoint - which is incorrect.

We originally didn't encounter this because we eagerly decomposed in
Space intersection, while now we've dispatched it to provablyDisjoint.

(edit) We allow for some kindness in provablyDisjoint.

Author: dwijnand

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

@@ -2841,10 +2841,12 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case (tp1: TypeRef, tp2: TypeRef) if tp1.symbol.isClass && tp2.symbol.isClass =>
         val cls1 = tp1.classSymbol
         val cls2 = tp2.classSymbol
-        def isDecomposable(tp: Symbol): Boolean =
-           tp.is(Sealed) && !tp.hasAnonymousChild
+        val sameKind = tp1.hasSameKindAs(tp2)
+        def isDecomposable(sym: Symbol): Boolean =
+          sameKind && sym.is(Sealed) && !sym.hasAnonymousChild
         def decompose(sym: Symbol, tp: Type): List[Type] =
-          sym.children.map(x => refineUsingParent(tp, x)).filter(_.exists)
+          val tpSimple = tp.applyIfParameterized(tp.typeParams.map(_ => WildcardType))
+          sym.children.map(x => refineUsingParent(tpSimple, x)).filter(_.exists)
         if (cls1.derivesFrom(cls2) || cls2.derivesFrom(cls1))
           false
         else

tests/pos/i19031.ci-reg1.scala

@@ -0,0 +1,12 @@
+//> using options -Werror
+
+sealed trait Mark[T]
+
+trait Foo[T]
+class Bar1[T] extends Foo[T]
+class Bar2[T] extends Foo[T] with Mark[T]
+
+class Test:
+  def t1(foo: Foo[Int]): Unit = foo match
+    case _: Mark[t] =>
+    case _          =>