False negative: equal Maps with duplicate-shaped keys (greedy matching)

Nobody has claimed this yet.

Greedy key matching produces a **false negative** on genuinely equal Maps
when multiple keys are structurally equal:

```js
import { dequal } from 'dequal';

const A = new Map([[{}, 1], [{}, 2]]);
const B = new Map([[{}, 2], [{}, 1]]);

console.log(dequal(A, B)); // false — but both are the same multiset of entries ({}→1, {}→2)
```

The matcher pairs each key of `A` with the *first* structurally-equal key of
`B` and never reconsiders, so when that first pairing has the wrong value the
whole comparison fails even though a valid pairing exists. Deciding this
correctly needs backtracking (or equivalent) over equal-key groups.

Related but distinct from #31: that one is a false *positive* on Sets
(overcounting); this is a false *negative* on Maps (greedy undercounting).
Both stem from element matching without multiplicity/backtracking.

Found by an 8,000-pair differential fuzz against a brute-force matcher;
happy to share more failing cases if useful (they're all this shape:
duplicate-structural keys whose values differ per pairing).

Start by locating the Map comparison path and any existing collection-equality tests. Reproduce the two Maps from the issue, then add a regression case covering structurally equal duplicate keys with different values. Done means equal Maps return true without breaking existing Map and Set comparisons.

Written by the indexing model from the issue text.