Type inference should success with generic trait and placeholder

Here's an example (play):

trait Tr<Ctx> {
    fn foo();
}

trait DefaultCtx {}

impl<T: Default, Ctx: DefaultCtx> Tr<Ctx> for T {
    fn foo() {}
}

struct OneDefaultCtx;

impl DefaultCtx for OneDefaultCtx {}

fn main() {
    <i32 as Tr<_>>::foo();
}

The context type Ctx cannot be inferred even though:

1. i32 implements Default
2. There's at least one type (OneDefaultCtx) that implements DefaultCtx
3. The trait method foo() doesn't use Ctx in its signature

Is this inability to infer Ctx an intentional design choice in Rust (perhaps due to coherence rules, ambiguity, or other language design principles), or is it a current limitation of the compiler's type inference that might be improved in the future?

Start with the linked Rust Playground example and reproduce the generic-trait placeholder inference behavior using the nightly 2024 edition configuration shown. Investigate whether the result follows from coherence, ambiguity, or an intentional inference rule. Done means documenting the cause and whether the compiler behavior is a limitation that can be improved.