Conflicting implementation should not exist after generic trait paramters have been constrained to associated types

Consider this code. Currently it cannot compile.

pub trait Foo {}

pub trait ImplBy {
    type Impl;
}

pub trait FooBy<I> {}

impl<T> Foo for T
where
    T: ImplBy,
    T: FooBy<T::Impl>,
{
}

struct Bar;
impl ImplBy for Bar {
    type Impl = ();
}
impl Foo for Bar {}
// conflicting implementations of trait `Foo` for type `Bar`
// downstream crates may implement trait `FooBy<_>` for type `Bar`

The type solver assumed downstream can impl FooBy<Bar::Impl> for type Bar. But this is easy to reject with orphan rules. Bar::Impl must be in the same scope as Bar itself. Therefore FooBy<Bar::Impl> cannot be implemented on Bar outside its origin crate.

Start by reproducing the minimized Rust example in the issue and inspect how the type solver applies orphan rules to the associated type constraint. Trace the relevant compiler handling for overlapping implementations; done means the explicit Foo implementation for Bar is no longer rejected as conflicting when the downstream implementation is impossible.