plan/spec: hashed indexes are done, the implication test is next

`tests/spec/indexes/` is 42/42, so all four recorded corpora are green:
positional 51, operators 125, indexes 42, aggregate 70.

Records what implementing the row taught, including the three things the
design review got wrong. Two were already noted when the corpus was
recorded ($in is allowed; a differing filter is 86); the third is new and
cheaper than the review's version: hashed needs no flags bit, because it
belongs to a key *component* and the per-component direction byte was
already there holding 0 or 1.

Also fixes a corpus case that did not measure what it said. "equality
across numeric types" sent an int32, because a source is plain JSON and
`5.0` is `5` after JSON.parse -- it was a second copy of the case above
it. Reading sources as EJSON was tried and reverted, and the recorder now
says why: EJSON's wrapper namespace collides with the query operators
these sources are made of, so `{"$regex": "x"}` became a BSONRegExp,
`structuredClone` flattened it to `{pattern, options}`, and "a filter
using $regex is refused" silently became a filter mongod accepts. The
cross-type property is a unit test instead, which is where it belongs --
it is about how this server hashes, and mongod's hash is a different
function, so a corpus could only ever check the answer.

The case is renamed to what it does measure rather than deleted: two
documents sharing a value is still the read a hashed index exists for.

Verified: 256/256 unit tests in ReleaseFast and ReleaseSafe, 87/87 fuzz,
all four corpora 0 fail, pinned scorecard unchanged at 228/63/196, the
full e2e matrix and crash-fuzz green.

tests/spec/indexes/record.js

@@ -68,6 +68,15 @@ async function main() {
         .filter((f) => !ONLY || f === ONLY || f === ONLY + '.json')
         .sort();
     for (const file of sources) {
+        // Plain JSON, deliberately, and the cost is worth stating: a source
+        // cannot name a BSON type the JSON grammar has no syntax for, so
+        // `5.0` reaches the driver as an int32 and no source here can ask a
+        // cross-type question. Reading sources as EJSON instead was tried and
+        // reverted -- EJSON's wrapper namespace collides with the query
+        // operators these sources are made of. `{"$regex": "x"}` parses to a
+        // BSONRegExp, `structuredClone` below then flattens it to
+        // `{pattern, options}`, and "a filter using $regex is refused"
+        // silently became a filter mongod accepts.
         const src = JSON.parse(fs.readFileSync(path.join(SRC_DIR, file), 'utf8'));
         const name = path.basename(file, '.json');
         const out = await record(client, name, src);