How should try_as_dyn handle inductive cycles?

struct Thing<T>(T);
trait Trait {}
impl<T> Trait for Thing<T> where Thing<T>: Trait {}

fn main() {
    require_trait::<Thing<i32>>();
}

fn require_trait<T: Trait>() {}

error[E0275]: overflow evaluating the requirement `Thing<i32>: Trait`
 --> src/main.rs:6:5
  |
6 |     require_trait::<Thing<i32>>();
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
note: required by a bound in `require_trait`
 --> src/main.rs:9:21
  |
9 | fn require_trait<T: Trait>() {}
  |                     ^^^^^ required by this bound in `require_trait`

For more information about this error, try `rustc --explain E0275`.

#![feature(try_as_dyn)]
#![recursion_limit = "8"]

use std::any::try_as_dyn;

struct Wrap<T>(T);
struct Indirect<T>(T);

trait Trait {}

impl<T> Trait for Wrap<T> where Indirect<Indirect<T>>: Trait {}
impl<T> Trait for Indirect<T> where T: Trait {}
impl Trait for i32 {}

// Uncommenting the below line makes the code compile
// #[inline]
pub fn weird() {
    let x = Wrap(Wrap(Wrap(Wrap(1i32))));
    let b = try_as_dyn::<Wrap<Wrap<Wrap<Wrap<i32>>>>, dyn Trait>(&x).is_some();
    println!("{b}");
}

error[E0275]: overflow evaluating the requirement `Indirect<Indirect<Wrap<i32>>>: Trait`
   |
   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "16"]` attribute to your crate (`playground`)
note: required for `Wrap<Wrap<i32>>` to implement `Trait`
  --> src/lib.rs:11:9
   |
11 | impl<T> Trait for Wrap<T> where Indirect<Indirect<T>>: Trait {}
   |         ^^^^^     ^^^^^^^                              ----- unsatisfied trait bound introduced here
   = note: 6 redundant requirements hidden
   = note: required for `Wrap<Wrap<Wrap<Wrap<i32>>>>` to implement `Trait`

For more information about this error, try `rustc --explain E0275`.

#![feature(try_as_dyn)]
use std::any::try_as_dyn;

trait Marker {
    type Assoc;
}
impl<T> Marker for T {
    type Assoc = Option<T>;
}

struct Thing<T>(T);
trait Trait {}
impl<T> Trait for Thing<T> where Thing<<T as Marker>::Assoc>: Trait {}

fn main() {
    try_as_dyn::<_, dyn Trait>(&Thing(0i32)).unwrap();
}

error[E0275]: overflow evaluating the requirement `Thing<Option<Option<Option<Option<Option<Option<...>>>>>>>: Trait`
  --> src/main.rs:13:63
   |
13 | impl<T> Trait for Thing<T> where Thing<<T as Marker>::Assoc>: Trait {}
   |                                                               ^^^^^
   |
   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`playground`)
note: required for `Thing<Option<Option<Option<Option<Option<Option<Option<...>>>>>>>>` to implement `Trait`
  --> src/main.rs:13:9
   |
13 | impl<T> Trait for Thing<T> where Thing<<T as Marker>::Assoc>: Trait {}
   |         ^^^^^     ^^^^^^^^                                    ----- unsatisfied trait bound introduced here
   = note: 125 redundant requirements hidden
   = note: required for `Thing<Option<T>>` to implement `Trait`
   = note: the full name for the type has been written to '/playground/target/debug/deps/playground-1025e5d410fc3651.long-type-10312360702417460169.txt'
   = note: consider using `--verbose` to print the full type name to the console

For more information about this error, try `rustc --explain E0275`.

#![feature(try_as_dyn)]
use std::any::try_as_dyn;

struct Thing<T>(T);
trait Trait {}
impl<T> Trait for Thing<T> where Thing<T>: Trait {}

fn main() {
    try_as_dyn::<_, dyn Trait>(&Thing(0i32)).unwrap();
}

thread 'main' (12) panicked at src/main.rs:9:46:
called `Option::unwrap()` on a `None` value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

#![feature(try_as_dyn)]

use std::any::try_as_dyn;
trait Apply {
    type Output<T: Trait>: Trait;
}
struct Identity;
impl Apply for Identity {
    type Output<T: Trait> = T;
}

struct Thing<A: Apply>(A);

trait Trait {}

impl<A: Apply> Trait for Thing<A> where <A as Apply>::Output<Self>: Trait {}

/*
effectively:
impl Trait for Thing<Identity> where Thing<Identity>: Trait {}
*/

fn foo<T: Trait + 'static>(x: T) {
    // This panics even though we have T: Trait
    let _ = try_as_dyn::<_, dyn Trait>(&x).unwrap();
}

fn bar<A: Apply + 'static>(a: A) {
    foo(Thing(a));
}

fn main() {
    bar(Identity);
}

thread 'main' (41) panicked at src/main.rs:25:44:
called `Option::unwrap()` on a `None` value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace