Hygienic macros lead to incorrect resolved types of internal variables

[DeltaEpsilon7787]

rust-analyzer version: 0.3.2029 & 0.4.2031
rustc version: rustc 1.76.0
editor or extension: VSCode, also Sublime Text, though irrelevant, this is a general LSP issue

code snippet to reproduce:
Refer to this issue for the first discovery: rust-itertools/itertools#970

Equivalent itertools reproducing code

fn main() {
    macro_rules! izip {
        // @closure creates a tuple-flattening closure for .map() call. usage:
        // @closure partial_pattern => partial_tuple , rest , of , iterators
        // eg. izip!( @closure ((a, b), c) => (a, b, c) , dd , ee )
        ( @closure $p:pat => $tup:expr ) => {
            |$p| $tup
        };
    
        // The "b" identifier is a different identifier on each recursion level thanks to hygiene.
        ( @closure $p:pat => ( $($tup:tt)* ) , $_iter:expr $( , $tail:expr )* ) => {
            izip!(@closure ($p, b) => ( $($tup)*, b ) $( , $tail )*)
        };
    
        // unary
        ($first:expr $(,)*) => {
            std::iter::IntoIterator::into_iter($first)
        };
    
        // binary
        ($first:expr, $second:expr $(,)*) => {
            std::iter::Iterator::zip(
                std::iter::IntoIterator::into_iter($first),
                $second,
            )
        };
    
        // n-ary where n > 2
        ( $first:expr $( , $rest:expr )* $(,)* ) => {
            {
                let iter = std::iter::IntoIterator::into_iter($first);
                $(
                    let iter = std::iter::Iterator::zip(iter, $rest);
                )*
                std::iter::Iterator::map(
                    iter,
                    izip!(@closure a => (a) $( , $rest )*)
                )
            }
        };
    }

    let alpha = vec![1, 2, 3, 4];
    let beta = vec!["One", "Two", "Three", "Four"];
    let gamma = vec![1.0, 4.0, 9.0, 16.0];

    let it = izip!(alpha, beta, gamma);
    
    // b here is resolved to be f64, but it's actually &str
    for (a, b, c) in it {
        println!("{} {} {}", a, b, c);
    }
}

but it does compile (if acos line is removed) and outputs as expected

thus the LSP is wrong

[Veykril]

Duplicate of #11681