feat: add testing entrypoint with recordHooks - #52

The docs build is what verifies the generated markdown, and it does so on the
real pages rather than on a fixture.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

`TaggedUtilities.vue` imported `utilityCategories` from `utilities.ts`, a module
that reads the source tree with `fs`, `typescript` and `prettier`. That put the
whole thing into the client graph, where vite replaces the node built-ins with
stubs — and the first `createRequire` call from typescript took every page down
with `createRequire is not a function`, since the component is registered
globally. Only `docs:dev` was affected: the production build tree-shakes the
unused imports away, while the dev server serves whole modules.

The vocabulary now lives in its own dependency-free module, beside the tag
vocabulary it mirrors. `utilities.ts` does not re-export it, so the only way to
reach it is the safe one; its types stay where they are, being erased anyway.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

`isContext` narrowed by path, type and method, but not by the record a
`get`/`update`/`patch`/`remove` addresses:

    isContext({ method: 'patch', id: 1 })
    isContext({ method: ['patch', 'remove'], id: null })

`null` is a value to match rather than a way of saying "no criterion", since
that is what feathers puts on the context for the multi variants — so unlike
the other criteria, only `undefined` means "not given" here. Ids are compared
strictly: `3` does not match `'3'`.

`checkContext` accepts the criterion along with the rest of `IsContextOptions`
and now names a mismatching id in its error, which it would otherwise have
reported as an empty pair of parentheses.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The record could only be read after the fact, so a test that wanted the first
call — or wanted to prove that no call happened — had to sleep first.

    const [context] = await calls.waitFor({ context: { method: 'create' } })
    await calls.waitFor({ context: { path: 'users' }, count: 0 })

`count` is how many matching calls to wait for, counting the ones already in
the record. `0` inverts the wait: it resolves once the window has passed
without a match and rejects the moment one arrives, so the test fails
immediately instead of sleeping and asserting afterwards.
`resetBefore`/`resetAfter` forget the matching calls around the wait, and both
`waitFor` and `reset` take either `isContext` criteria or a predicate.

Timeouts follow `waitForServiceEvent` — a number of milliseconds or `false` —
with one exception: `count: 0` always waits its window out, so it defaults to
a short one and refuses `false`, which could never settle.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

An axis the Context group was missing: utilities that read the call itself —
`method`, `type`, `path`, `id`, `service` — rather than one of its payloads.
Tags `isContext`, `checkContext`, `contextToJson` and `debug`.

Three things a test could not say before, all of them from real use:

- `waitFor({ count: 0 })` rejected on a match already in the record, and the
  only way around it forgot the very call the test still needed as evidence.
  `since: 'now'` takes the baseline at the wait instead, leaving the record
  alone: `{ count: 0, since: 'now' }` is "no *further* call".
- `quietFor` resolves once nothing matching has arrived for that long, with
  every match it saw — the debounce-shaped wait, and the exact assertion that
  `count` cannot give, since `count` is a lower bound. It has to be shorter
  than `timeout`, which stays the hard deadline.
- `recordHooks` registered the `before` hook only, so `calls.after` was
  silently empty and waiting for it could only time out. It now records
  `before`, `after` and `error` by default — so `calls.all` holds two entries
  per call, while the per-type indexes stay the per-call view. `around` is
  still opt-in: at the point it records it sees what `before` sees. A wait for
  a type that is not recorded now rejects immediately and names the fix.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Recording `before` and `after` by default made one call two entries, and
`waitFor` counted those: a single call satisfied `count: 2`, and `quietFor`
resolved with two contexts for it.

A recorded entry now maps back to the context of the call it came from — the
one object feathers reuses for the whole call — so a call counts once and the
wait resolves with one context per call, the first entry recorded for it. The
timeout message counts the same way.

Two consequences fall out of that mapping. With `since: 'now'`, the calls
already out are remembered, so one of them coming back is not a further call
and neither counts nor trips `count: 0`. And `resetAfter` together with
`since: 'now'` is refused: one keeps the evidence that is already recorded,
the other forgets it.