Evaluating trait requirements with higher-rank trait bounds overflows

[misha-antonenko]

I am trying to implement a trait for types T such that &T is convertible into an iterator:

trait Scan {
    fn scan(&self);
}

impl<T> Scan for &T
where
    T: Scan,
{
    fn scan(&self) {
        self.scan();
    }
}

impl<Iterable> Scan for Iterable
where
    for<'a> &'a Iterable: IntoIterator,
    for<'a> <&'a Iterable as IntoIterator>::Item: Scan,
{
    fn scan(&self) {
        for item in self.into_iter() {
            item.scan();
        }
    }
}

struct Foo(i32);

impl Scan for Foo {
    fn scan(&self) {}
}

fn main() {
    let v = vec![Foo(1)];
    Scan::scan(&v);
}

The rationale behind this is to be able to call scan on objects without consuming them.

The compiler fails here, though, on both the stable 1.66.0 and the nightly versions:

error[[E0275]](https://doc.rust-lang.org/stable/error-index.html#E0275): overflow evaluating the requirement `for<'a> <&'a _ as IntoIterator>::Item: Scan`
   |
   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`playground`)
note: required for `<&'a _ as IntoIterator>::Item` to implement `for<'a> Scan`
  --> src/main.rs:14:16
   |
14 | impl<Iterable> Scan for Iterable
   |                ^^^^     ^^^^^^^^
   = note: 126 redundant requirements hidden
   = note: required for `<&'a &_ as IntoIterator>::Item` to implement `for<'a> Scan`

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

I am aware of a similar issue #37748.