rustc: Tweak the borrow on closure invocations

This alters the borrow checker's requirements on invoking closures from          
requiring an immutable borrow to requiring a unique immutable borrow. This means 
that it is illegal to invoke a closure through a `&` pointer because there is no 
guarantee that is not aliased. This does not mean that a closure is required to  
be in a mutable location, but rather a location which can be proven to be        
unique (often through a mutable pointer).                                        
                                                                                 
For example, the following code is unsound and is no longer allowed:             
                                                                                 
    type Fn<'a> = ||:'a;                                                         
                                                                                 
    fn call(f: |Fn|) {                                                           
        f(|| {                                                                   
            f(|| {})                                                             
        });                                                                      
    }                                                                            
                                                                                 
    fn main() {                                                                  
        call(|a| {                                                               
            a();                                                                 
        });                                                                      
    }                                                                            
                                                                                 
There is no replacement for this pattern. For all closures which are stored in   
structures, it was previously allowed to invoke the closure through `&self` but  
it now requires invocation through `&mut self`.                                  
                                                                                 
The standard library has a good number of violations of this new rule, but the   
fixes will be separated into multiple breaking change commits.                   
                                                                                 
Closes #12224