Allow lifetime polymorphism in local bindings

The following example doesn't compile in current Rust:

fn main() {
    let id = |x: &i32| x;
    {
        let a: Box<i32> = Box::new(42);
        id(&a);
    }
    {
        let b: Box<i32> = Box::new(43);
        id(&b);
    }
}

This is because a and b have non-overlapping lifetimes, so id cannot be fixed to either of them.

The typical solution is to lift id into a fn, making the lifetime parameter polymorphic:

fn id<'a>(x: &'a i32) -> &'a i32 { x }
// ...

But then we lose the ability to close over the environment.

Ideally, I'd like the compiler to accept something like this:

let id = for<'a> |x: &'a i32| -> &'a i32 { x };

that is, a closure which is polymorphic over the lifetime rather than fixed to a particular one.

Start with the closure examples and lifetime explanation in the issue, then investigate how Rust represents closure lifetimes and environment captures. Determine the design and implementation scope for lifetime-polymorphic local closures. Done requires a settled approach and corresponding compiler or RFC work that supports the requested behavior.