feat(workflow): document-wait task + 30-day timeout cancellation (S-10a, closes #102) (#105)

## What & why

S-10a, the **workflow/timeout spine** of the (split) document-upload slice: the registratie process
now parks at a **`WachtOpDocumenten`** user task with an **interrupting `P30D` boundary timer**. When
the documents arrive the task completes and the process continues into the diploma routing (S-13) →
Beoordelen; if the 30 days lapse, the timer cancels the wait, runs a `RegistratieVerlopen`
external-worker task, and the domain expires the aggregate to a new terminal status **`Verlopen`**.
Backend only — the real upload trigger (portal → BFF → ACL → Documenten API) is S-10b (#103).

Closes #102

Mechanism recorded in **ADR-0017**; opened as proposal #104. Mirrors the S-14 escalation
(boundary-timer + external-worker) and S-11 withdrawal (interrupting cancel) patterns.

## Definition of Done

- [x] Linked Gitea issue (above).
- [x] Failing test committed before the implementation (red→green pairs per layer).
- [x] Implementation makes the test pass.
- [x] Conventional Commits referencing the issue (`refs #102`).
- [ ] CI green — all Gitea Actions jobs (pending on this PR).
- [x] `docker compose up` health unaffected (no new services; deploy path unchanged).
- [x] Docs updated (ADR-0017, demo-script, BACKLOG split).
- [x] ADR added (`docs/architecture/adr-0017-document-wait-timeout-cancellation.md`).
- [x] Demo note in `docs/demo-script.md`.

## Notes for reviewers

- **Domain** (`Registration.Expire()` + `Verlopen`), **application** (`ExpireRegistrationWorker`),
  **infra** (`RegistratieVerlopenProcessor`/`Pump`, `IRegistratieVerlopenClient`, Flowable
  acquire/complete + `CompleteDocumentWaitAsync`) — the timeout counterpart to the OpenZaak/escalation
  worker trios; idempotent per §8.6.
- **BPMN** verified live against a `flowable-rest` probe: complete `WachtOpDocumenten` → routes to
  Beoordelen; fire the P30D timer → `RegistratieVerlopen` job (carrying `registrationId`) + the wait
  task cancelled. `verify-domain` exercises both branches in-stack (completes the wait in every existing
  block; fires the timer and asserts `Verlopen` in a new block).
- **Scope boundary:** on expiry the aggregate goes `Verlopen` and the process ends, but the ZGW *zaak*
  is not yet set to a cancellation status — that needs a new ACL method + statustype seeding and is
  folded into S-10b (noted in ADR-0017).
- `CompleteDocumentWaitAsync` is built and HTTP-tested here but not yet called from a domain endpoint;
  S-10b wires the upload trigger to it.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reviewed-on: #105

tests/acceptance/Steps/EenDocumentTermijnVerlopenSteps.cs

@@ -0,0 +1,52 @@
+using Acceptance.Support;
+using Big.Application;
+using Big.Domain;
+using Big.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Reqnroll;
+using Xunit;
+
+namespace Acceptance.Steps;
+
+/// <summary>Bindings for <c>EenDocumentTermijnVerlopen.feature</c> (S-10a). Drives the timeout worker
+/// (<see cref="RegistratieVerlopenProcessor"/> over the <see cref="ExpireRegistrationWorker"/>) against
+/// an in-memory Flowable stand-in and a shared registration store; one instance per scenario. The
+/// interrupting 30-day timer either cancels the wait and expires the registration, or — if the
+/// documents arrived first — never fires; the scenario asserts on the aggregate's status.</summary>
+[Binding]
+[Scope(Feature = "Een documenttermijn laten verlopen")]
+public sealed class EenDocumentTermijnVerlopenSteps
+{
+    private readonly InMemoryDocumentTimeoutClient _flowable = new();
+    private readonly Support.InMemoryRegistrationStore _store = new();
+    private Registration _registration = null!;
+    private string _processInstanceId = "";
+
+    [Given("a registration parked at the WachtOpDocumenten task")]
+    public async Task GivenARegistrationParkedAtWachtOpDocumenten()
+    {
+        _registration = Registration.Submit("123456782");
+        await _store.SaveAsync(_registration);
+        _processInstanceId = _flowable.ParkWaitingForDocuments(_registration.Id);
+    }
+
+    [When("the 30-day document timer fires")]
+    public void WhenTheDocumentTimerFires() => _flowable.FireDocumentTimer(_processInstanceId);
+
+    [When("the documents arrive before the timer fires")]
+    public void WhenTheDocumentsArriveBeforeTheTimer() => _flowable.ReceiveDocuments(_processInstanceId);
+
+    [When("the document-timeout worker runs")]
+    public async Task WhenTheTimeoutWorkerRuns()
+        => await new RegistratieVerlopenProcessor(
+            _flowable, new ExpireRegistrationWorker(_store),
+            NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
+
+    [Then("the registration is verlopen")]
+    public async Task ThenTheRegistrationIsVerlopen()
+        => Assert.Equal(RegistrationStatus.Verlopen, (await _store.GetAsync(_registration.Id))!.Status);
+
+    [Then("the registration is not verlopen")]
+    public async Task ThenTheRegistrationIsNotVerlopen()
+        => Assert.Equal(RegistrationStatus.Ingediend, (await _store.GetAsync(_registration.Id))!.Status);
+}