Use upper bound of abstract types in exhaustivity checking

[nox213]

closes #23620, #24246

If the upper bound of an abstract type is not sealed but is effectively sealed, it is not handled correctly, since classSym could return a type that is not sealed (Object in the issue above).
If the type were not abstract, it would pass the logic that checks whether it is an Or, And, etc., and would be handled properly.
This PR makes exhaustivity checking use the upper bound of abstract types that are effectively sealed.

[nox213]

@zielinsky Could you review this PR?

[zielinsky]

Since this change impacts abstract type members as well, could you add tests for them too?

[nox213]

Since this change impacts abstract type members as well, could you add tests for them too?

Sure, I made a test code like below.

trait Foo
trait Bar

trait AbstractType:
  type Type <: (Foo | Bar)

object FooOrBar extends AbstractType:
  type Type = Foo | Bar

trait Buz

@main def main =
  val p: FooOrBar.Type | Buz = new Buz {}

  p match
    case _: Foo => println("foo")
    case _: Buz => println("buz")
    case _: Bar => println("bar")

It passes well, but this abstract type member setup doesn't hide the implementation type, it doesn't reach the logic that I added.

   tpw.isInstanceOf[OrType] || // It is caught by this condition
      (tpw.isInstanceOf[AndType] && {
        val and = tpw.asInstanceOf[AndType]
        isCheckable(and.tp1) || isCheckable(and.tp2)
      }) ||
      tpw.isRef(defn.BooleanClass) ||
      classSym.isAllOf(JavaEnum) ||
      classSym.is(Case) ||
        (tpw.isInstanceOf[TypeRef] && {
          val tref = tpw.asInstanceOf[TypeRef]
          if (tref.symbol.isAbstractOrAliasType && !tref.info.hiBound.isNothingType) {
            println(s"  hibound: ${tref.info.hiBound}")
            isCheckable(tref.info.hiBound)
          } else
            false
        })

Is this expected, right?
If this is okay, I will add this test case.

[zielinsky]

@nox213,
@road21 created an issue (#24246) where there is a perfect test for type parameters ("abstract" type in terms of isAbstractOrAliasType). Could you add it also?

The test you sent does not test the change you made, so there is no point in adding it :/
Here's a test for abstract type members

sealed trait S
trait Z

case object A extends S, Z
case object B extends S, Z

trait HasT:
  type T <: S & Z

def nonExhaustive(h: HasT, x: h.T) =
  x match 
    case A => ()

[zielinsky]

LGTM!