Compiler hang due to exponentially growing type using GAT

The following code (playground) causes a compiler hang:

trait Ty: Deferred {
    type Gat<T>: Ty;
}
trait Deferred {
    type Eval: Ty;
}

type G<A, B> = <Eval<A> as Ty>::Gat<B>;
type Eval<N> = <N as Deferred>::Eval;

pub struct Rec<L, R>(L, R);
impl<L: Deferred, R: Deferred> Deferred for Rec<L, R> {
    type Eval = G<
        L,
        G<
            Eval<
                Rec<
                    L::Eval, //
                    R::Eval,
                >,
            >,
            Eval<
                Rec<
                    L::Eval, //
                    R::Eval,
                >,
            >,
        >,
    >;
}

impl Ty for () {
    type Gat<T> = ();
}
impl Deferred for () {
    type Eval = Self;
}
fn main() {
    size_of::<Eval<Rec<(), ()>>>();
}

Some notes about the code:

• Rec::<L,R>::Eval expands to G<L, G<Rec::<L', R'>::Eval, Rec::<L',R'>::Eval>>, an infinite loop with exponential growth.
• G<L, ...> looks redundant, but is somehow necessary.
• From my testing, G must be a GAT.
• The compiler correctly errors when using -Znext-solver.

Versions: Stable 1.95.0, Nightly 2026-04-09

Start with the linked Rust Playground reproducer and compare stable behavior with -Znext-solver, which the report says rejects the example. Trace the GAT and type-alias evaluation path responsible for the expanding Rec::Eval projection; done means the compiler no longer hangs on the reproducer and retains the reported diagnostic behavior.