Incorrectly and non-idempotently modifies `..` in macro

Start with this:

fn a() {
    a!(b {
        c: d,
        //
        ..
    });
}

Rust rustfmt, and you get this:

fn a() {
    a!(b {
        c: d,
        //
        ..
        ..
    });
}

Run it a third time, and you get this:

fn a() {
    a!(b {
        c: d,
        //
        ....
    });
}

And then we have a fixed point.

This can cause rustfmt to break certain macro-using code. The behavior still exists if you substitute a rather than a!, and I guess it's weird if it's not idempotent, but it's a bit of an edge case since that is not syntactically valid rust anyway. But you can write fully-compilable code that exhibits this behavior when formatted with rustfmt, if you're using certain macros like assert_matches!.

Start by reproducing the minimal macro example with rustfmt and compare its output across repeated runs. Trace the formatting path for .. inside macro input, then add a regression test showing that formatting is idempotent and does not duplicate or merge the dots.