Compiling fails as a sync function but succeeds in async function

The code can be compiled, but uncommentting the non_async_function2 and calling it in async_function will fail the compiling.

pub fn fx<'a, T: 'a, U>(_: &mut &'a mut T) -> fn(&mut &'a mut U) {
    fn f<'b, T: 'b>(_: &mut &'b mut T) {}
    f::<U>
}

struct PrintOnDrop<'a>(&'a mut String);
impl<'a> Drop for PrintOnDrop<'a> {
    fn drop(&mut self) {}
}

pub async fn async_function() {
    //pub fn non_async_function2() { 
        let mut m = "m".to_owned();
        let mut n = "n".to_owned();
        {
            let mut x1 = &mut m; // &'1 mut m
            let f = fx(&mut x1);
    
            let m1 = PrintOnDrop(x1);
            {
                let mut n1 = PrintOnDrop(&mut n);
    
                println!();
                drop(m1);
    
                f(&mut &mut n1);  // &mut &'1 mut n1
            }
        }
   // }
   // non_async_function2();
}

pub fn usage() -> Box<dyn std::future::Future<Output = ()>> {
    Box::new(async_function())
}

Start by compiling the supplied reproducer with the non_async_function2 block uncommented, then compare it with the async_function version that succeeds. Focus on the lifetime interactions in fx, PrintOnDrop, and the call to f; done means the reported code compiles consistently in both contexts without regressing the async case.