function call inference incorrectly handles autoderef chains which encounter infer

fn main() {
    let mut x: Option<Box<_>> = None;
    loop {
        if let Some(x) = x {
            x();
            break;
        } else {
            let str = String::new();
            x = Some(Box::new(move || drop(str)));
        }
    }
}

This results in

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
 --> src/main.rs:9:31
  |
5 |             x();
  |             --- the requirement to implement `Fn` derives from here
...
9 |             x = Some(Box::new(move || drop(str)));
  |                               ^^^^^^^      --- closure is `FnOnce` because it moves the variable `str` out of its environment
  |                               |
  |                               this closure implements `FnOnce`, not `Fn`
  |
  = note: required for `Box<{closure@src/main.rs:9:31: 9:38}>` to implement `Fn()`

When typechecking the function call x() we only test whether Box<?infer>: Fn results in an error. It does not so that's what we select for the call.

This differs from the way method selection works where autoderef chains encountering inference variables result in ambiguity errors.

Start with the provided reproducer and the function-call type-checking path where Box<?infer>: Fn is tested. Compare that behavior with method selection when autoderef encounters inference variables. Done means the function call no longer selects an incorrect Fn requirement and the reproducer is covered by a regression test.