function call inference incorrectly handles autoderef chains which encounter infer

[lcnr]

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.

[tusharrrr1]

Use Box<dyn FnOnce()>

1. If your closure really only needs to run once (which fits your code: it breaks right after calling it), then you should change the type

2. If you want Fn (callable multiple times)

Then the closure must not move ownership of its captured variable.
let me fix this if possible