Name the intake action the route actually writes, and stop awaiting the delegate notice

The activity feed maps an audit action to a sentence. The web client posts to
/api/medications/[id]/intake, which has audited as `medication.intake` since
v1.0.0, but the map only knew `medications.intake.update` — so a delegate
recording a dose showed up in the owner's feed with no verb at all. Both
spellings are recognised now, plus `measurement.create.batch`.

A new test reads the audit actions straight out of every route that calls
requireRecordAuth("write") and fails when one has no case in the map, so the
next route to be opened for delegates cannot land a silent gap.

The delegate notification is fire and forget now, like every neighbouring
side effect. The dispatcher awaits each channel in the cascade, so one
unreachable channel added its whole timeout to the request of the person
standing next to the patient waiting for a dose to register. The integration
test polls the ledger rather than relying on the await, so nothing about the
proof weakens.

src/app/api/medications/[id]/intake/route.ts

@@ -533,7 +533,14 @@ async function postIntake(request: NextRequest, { params }: RouteParams) {
   // v1.36.x — "somebody else marked your dose". This route has no snooze arm,
   // so the state is whichever of the two markings the payload carried. The
   // helper refuses on self, so a person marking their own dose is unaffected.
-  await notifyDelegatedIntake({
+  // Fire and forget, like every neighbour above. The dispatcher awaits each
+  // channel in the cascade, so an unreachable one would have added its whole
+  // timeout to the caregiver's request — the person standing next to the
+  // patient waiting for a dose to register. The helper never throws, and the
+  // owner learning a moment later is the right trade against the tick being
+  // slow. The integration test already polls the ledger rather than relying on
+  // the await, so nothing about the proof weakens.
+  void notifyDelegatedIntake({
     ownerId: user.id,
     actorId: actor.id,
     medicationId: id,

src/app/api/medications/intake/route.ts

@@ -560,7 +560,14 @@ export const POST = apiHandler(async (request: NextRequest) => {
   // on a snooze, resolves both names itself, and never throws; awaited because
   // the latency it adds lands on the caregiver's request and never on the
   // owner's own hot path.
-  await notifyDelegatedIntake({
+  // Fire and forget, like every neighbour above. The dispatcher awaits each
+  // channel in the cascade, so an unreachable one would have added its whole
+  // timeout to the caregiver's request — the person standing next to the
+  // patient waiting for a dose to register. The helper never throws, and the
+  // owner learning a moment later is the right trade against the tick being
+  // slow. The integration test already polls the ledger rather than relying on
+  // the await, so nothing about the proof weakens.
+  void notifyDelegatedIntake({
     ownerId: user.id,
     actorId: actor.id,
     medicationId: existing.medicationId,