Improve spans of named lifetimes generated from elided lifetimes

Currently fails to compile:

    error: future cannot be sent between threads safely
        --> tests/test.rs:1506:41
         |
    1506 |         async fn take_ref(&self, _: &T) {}
         |                                         ^^ future created by async block is not `Send`
         |
    note: captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
        --> tests/test.rs:1506:34
         |
    1504 |     #[async_trait]
         |     -------------- in this procedural macro expansion
    1505 |     impl<T> Generic<T> for One {
    1506 |         async fn take_ref(&self, _: &T) {}
         |                                  ^ has type `&T` which is not `Send`, because `T` is not `Sync`
         = note: required for the cast from `[async block@tests/test.rs:1506:41: 1506:43]` to the object type `dyn futures::Future<Output = ()> + std::marker::Send`
         = note: this error originates in the attribute macro `async_trait` (in Nightly builds, run with -Z macro-backtrace for more info)
    help: consider restricting type parameter `T`
         |
    1505 |     impl<T: std::marker::Sync> Generic<T> for One {
         |           +++++++++++++++++++

    error[E0277]: `T` cannot be shared between threads safely
        --> tests/test.rs:1523:60
         |
    1523 |         async fn take_ref(&self, (_a, _b, _c): &(T, T, T)) {}
         |                                                            ^^ `T` cannot be shared between threads safely
         |
         = note: required because it appears within the type `(T, T, T)`
         = note: required for `&(T, T, T)` to implement `std::marker::Send`
    note: required because it's used within this `async` block
        --> tests/test.rs:1523:60
         |
    1523 |         async fn take_ref(&self, (_a, _b, _c): &(T, T, T)) {}
         |                                                            ^^
         = note: required for the cast from `[async block@tests/test.rs:1523:60: 1523:62]` to the object type `dyn futures::Future<Output = ()> + std::marker::Send`
    help: consider restricting type parameter `T`
         |
    1522 |     impl<T: std::marker::Sync> Generic<(T, T, T)> for Three {
         |           +++++++++++++++++++

Bypass Sync bound implied by non-existent drop of reference

Currently fails to compile:

    error: changes to closure capture in Rust 2021 will affect drop order
        --> tests/test.rs:1549:59
         |
    1549 |         async fn f(Tuple(_, _int): Tuple<Droppable, i32>) {}
         |                    --------------                         ^-
         |                    |                                       |
         |                    |                                       in Rust 2018, `__arg0` is dropped here, but in Rust 2021, only `__arg0.1` will be dropped here as part of the closure
         |                    in Rust 2018, this closure captures all of `__arg0`, but in Rust 2021, it will only capture `__arg0.1`
         |
         = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
    note: the lint level is defined here
        --> tests/test.rs:5:9
         |
    5    | #![deny(rust_2021_compatibility)]
         |         ^^^^^^^^^^^^^^^^^^^^^^^
         = note: `#[deny(rust_2021_incompatible_closure_captures)]` implied by `#[deny(rust_2021_compatibility)]`
    help: add a dummy let to cause `__arg0` to be fully captured
         |
    1549 |         async fn f(Tuple(_, _int): Tuple<Droppable, i32>) { let _ = &__arg0;}
         |                                                             ++++++++++++++++

    error: changes to closure capture in Rust 2021 will affect drop order
        --> tests/test.rs:1556:66
         |
    1556 |         async fn f(Tuple { 1: _int, .. }: Tuple<Droppable, i32>) {}
         |                    ---------------------                         ^-
         |                    |                                              |
         |                    |                                              in Rust 2018, `__arg0` is dropped here, but in Rust 2021, only `__arg0.1` will be dropped here as part of the closure
         |                    in Rust 2018, this closure captures all of `__arg0`, but in Rust 2021, it will only capture `__arg0.1`
         |
         = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
    help: add a dummy let to cause `__arg0` to be fully captured
         |
    1556 |         async fn f(Tuple { 1: _int, .. }: Tuple<Droppable, i32>) { let _ = &__arg0;}
         |                                                                    ++++++++++++++++

Make expansion of nested `_` and `..` patterns edition independent