Possibly incorrect check for lower bounds

[WojciechMazur]

Community build regression for https://github.com/johnhungerford/generic-schema (maintainer @johnhungerford)
Based on Open Community Build #2564
Part of #15647 regressions tracker

Compiler version

Works in 3.1.2
Fails in 3.1.3
Fails in 3.2.1-RC1-bin-20220712-7e20b81-NIGHTLY

Probably further minimization might be helpfull

Minimized code

type TypeName = String & Singleton

trait Subtype[T]:
  type Name <: TypeName
object Subtype:
  type Aux[T, N <: TypeName] = Subtype[T] { type Name = N }

trait SubtypeReplacer[N <: TypeName, NewSubT, R <: Tuple]:
  type Out
  def replace(subtypes: R, withSubtype: NewSubT): Out

object SubtypeReplacer {
  given found[N <: TypeName, NewSubT, OldT, Tail <: Tuple]
      : SubtypeReplacer[N, NewSubT, Subtype.Aux[OldT, N] *: Tail] with {
    type Out = NewSubT *: Tail

    override def replace(
        subtypes: Subtype.Aux[OldT, N] *: Tail,
        withSubtype: NewSubT
    ): Out = withSubtype *: subtypes.tail
  }

  def replace[N <: TypeName, NewSubT, R <: Tuple](
      typeName: N,
      from: R,
      withSubtype: NewSubT
  )(using
      strp: SubtypeReplacer[N, NewSubT, R]
  ): strp.Out = strp.replace(from, withSubtype)
}

Output

[error] ./test.scala:20:26: Type argument Tail does not conform to lower bound Tuple.Tail[Subtype.Aux[OldT, N] *: Tail]
[error]     ): Out = withSubtype *: subtypes.tail
[error]    

Expectation

Should compile

[griggt]

First bad commit is d1957e5 from #13780

[griggt]

This simpler example exhibits the same symptoms:

def foo[S, T, Tail <: Tuple](s: S *: Tail, t: T): T *: Tail = t *: s.tail

-- [E057] Type Mismatch Error: test.scala:1:64 ---------------------------------
1 |def foo[S, T, Tail <: Tuple](s: S *: Tail, t: T): T *: Tail = t *: s.tail
  |                                                                ^
  |  Type argument Tail does not conform to lower bound Tuple.Tail[S *: Tail]
  |
  |  Note: a match type could not be fully reduced:
  |
  |    trying to reduce  Tuple.Tail[S *: Tail]
  |    failed since selector  S *: Tail
  |    does not uniquely determine parameters _, xs in
  |      case _ *: xs => xs
  |    The computed bounds for the parameters are:
  |      _ >: S
  |      xs >: Tail <: Tuple
  |
  | longer explanation available when compiling with `-explain`

[odersky]

Thanks for narrowing it down! I guess that's then as specified.