`$crate` is treated as a normal identifier in a `macro_rules` matcher

I've found that, in some cases, inside a macro_rules matcher (the thing on the left of the =>), $crate is treated as if it's a normal identifier, which seems very weird. I'm not sure if this is intended or a bug.

This weirdness manifests in two different ways:

1. A $crate on its own in the matcher is treated as literally matching $crate, as opposed to being a metavariable or erroring:

macro_rules! foo {
    ($crate and $crate:tt) => {
        "wtf"
    }
}

macro_rules! bar {
    () => {
        foo!($crate and $crate:tt)
    }
}

fn main() {
    println!("{}", bar!());  // prints "wtf"
}

2. I can create a metavariable (e.g., the metavariable $x:tt has the name x) such that the metavariable's name is $crate:

macro_rules! bar {
    ($dol:tt) => {
        macro_rules! foo {
            ($dol $crate : expr) => { $dol $crate }
        }
    }
}

bar!($);

fn main() {
    println!("{}", foo!(1 + 2));  // prints 3
}

See also https://github.com/rust-lang/rust/issues/146967 and https://github.com/rust-lang/rust/issues/146968 and https://github.com/rust-lang/rust/issues/146114 for weirdness with $crate.

Meta

Reproducible on the playground with version 1.92.0-nightly (2025-09-24 caccb4d0368bd918ef66)

No repository file or test is named. Start by running both macro_rules reproductions on the reported Rust 1.92.0-nightly toolchain, then locate the compiler entry point that handles matchers and $crate. Add regression coverage for the two behaviors and verify the resulting behavior against the intended language rule.