GeezerVison

Delete a temporal-geometry member with deleteTime

Member deletion removes the addressed member sequence with deleteTime over its
time span, which drops the whole composing sequence and leaves the other members
as distinct sequences.

- MEOS dep from server.py and pytest test_mobility_api

feat(app): FastAPI routes for Dispatcher + WireCodec (step 5)

Adds mobilityapi/app.py + two routers that expose the catalog-driven
Dispatcher (PR #6) and WireCodec (PR #7) as HTTP endpoints:

  - GET  /catalog          -> list dispatcher-exposable functions
  - GET  /catalog/{name}   -> full signature for one function
  - POST /functions/{name} -> invoke with JSON body, decode/encode
                              opaque MEOS types via the WireCodec

The app is built by create_app(dispatcher, codec) — both dependencies
are explicit; no global singletons. Production wires both to PyMEOS;
tests pass stubs.

The POST /functions/{name} flow:
  1. Decode opaque-type params via codec.decode(encoding, wire_value).
  2. Dispatch via Dispatcher.dispatch(name, params).
  3. Encode the result via codec.encode(encoding, value) if the catalog
     marks the return as serialised.

Error mapping:
  - Unknown function           -> 404
  - Missing / extra parameters -> 400
  - Param encoding has no codec decoder -> 400
  - Result encoding has no codec encoder -> 500

tests/test_app.py: 11 HTTP-level tests against a tiny in-test catalog
covering scalar, serialised-in / scalar-out, and serialised-in /
serialised-out shapes, plus the four error paths. All 38 framework
tests pass.

chore(vendor): vendor MEOS-API artefacts (step 2 of the ingestion plan)

Vendor MobilityAPI's read-only copy of MEOS-API's published catalog +
projection artefacts under `vendor/meos-api/`, plus a Makefile target
`make vendor-meos-api` that regenerates them from upstream.

Files added:

  vendor/meos-api/
    PROVENANCE.json              -- per-artefact source URLs + regenerate cmd
    README.md                    -- refresh procedure
    meos-idl.json                -- 3546 fns / 70 structs / 16 enums
                                    (generated by MEOS-API run.py over
                                    MobilityDB master meos/include headers)
    meos-coverage.json           -- structural worklist (from open PR #4)
    meos-object-model-parity.json -- 29-pair portable-parity (from open PR #10)

The Makefile target clones MEOS-API + MobilityDB shallowly, installs
libclang, runs MEOS-API's `run.py` against MobilityDB's MEOS headers,
and copies the produced JSON artefacts into `vendor/meos-api/`.

Two of the four artefacts (`meos-coverage.json`,
`meos-object-model-parity.json`) currently come from open MEOS-API PR
branches because their generators are not yet on master; PROVENANCE.json
makes that explicit. The Makefile gracefully skips them if absent.

Step 2 of `docs/MEOS_API_INGESTION_PLAN.md`. The drift gate workflow
that fails on stale artefacts is step 3 (separate stacked PR).

ci(vendor): add vendor-drift workflow (step 3 of ingestion plan)

Adds `.github/workflows/vendor-drift.yml` which regenerates the
vendored MEOS-API artefacts (`make vendor-meos-api`) on every PR
touching `vendor/meos-api/`, the Makefile, or the workflow itself,
plus on push to master and on a daily 06:00 UTC cron. On drift it
fails with an actionable message:

  ::error::vendor/meos-api/ is stale. Run `make vendor-meos-api`
  locally and open a refresh PR.

This is step 3 of `docs/MEOS_API_INGESTION_PLAN.md` ("CI gate that
regenerates the vendored artefacts and fails the PR if they drift").

Stacks on PR #4 (vendoring + Makefile).

feat(resolvers,wire): pluggable resolvers + wire-layer codec (step 4)

Stacks on the #6 dispatcher foundation.  Adds the two layers a
production endpoint migration needs alongside the dispatcher:

mobilityapi/resolvers.py:
  - stub_resolver(registry)    — explicit name->callable map for tests
  - pymeos_resolver()          — production resolver that looks up
                                 functions in pymeos.functions; lazy-
                                 imports PyMEOS, raises ImportError
                                 with an actionable message when it's
                                 absent
  - default_resolver(prefer_pymeos=True) — production-first probe
                                 with a stub fallback that raises
                                 NotImplementedError on first call

mobilityapi/wire.py:
  - WireCodec                  — keyed by encoding name (mfjson, text,
                                 wkb, hexwkb); decode wire-value to
                                 PyMEOS obj; encode PyMEOS obj back
  - stub_codec(decoders, encoders) — explicit-map constructor for tests
  - pymeos_codec()             — production codec bridging to PyMEOS
                                 factory entry points
  - ENCODING_{MFJSON,TEXT,WKB,HEXWKB} — canonical encoding-name
                                 constants matching the catalog's
                                 x-meos-{decode,encode} fields

mobilityapi/__init__.py re-exports all three names so endpoint
migrations import from one module.

15 new unit tests (tests/test_resolvers.py + tests/test_wire.py),
all passing locally.  CI workflow's pytest job is extended to cover
all three test files together.

Production wiring lands when the first endpoint migrates: install
pymeos, replace getattr(pymeos.functions, name) plumbing with
default_resolver(), point WireCodec at pymeos_codec().  The
intervening migration PRs are bounded ~50-100 LoC each.

docs: MobilityAPI ingestion plan for MEOS-API output + OpenAPI missin…

…g-work integration

Authored as a parallel-session planning artefact.  Maps how MobilityAPI
consumes the catalog and projections published by MobilityDB/MEOS-API,
and integrates the missing-work items called out in MEOS-API PR #5
("natural follow-ups" — OpenAPI conformance validation in CI, and an
OGC API – Moving Features resource projection).

Sections:

* Context — MEOS-API as the SoT, MobilityAPI as the OGC-conformant
  downstream binding.
* Per-task split (parallel sessions) — what lives in MEOS-API session,
  what lives in MobilityAPI session, why they don't block each other.
* Missing OpenAPI work — three items from PR #5's follow-ups: MCP
  manifest (DONE in PR #6), conformance CI (MISSING — MEOS-API),
  MovFeat resource projection (MISSING — MEOS-API, immediate
  dependency for MobilityAPI).
* Endpoint-by-endpoint gap analysis — each of the 10 hand-written
  resource/* modules mapped to its generic-OpenAPI + MovFeat-projection
  equivalent.  Classified Replace (5: pure MEOS dispatchers) vs
  Keep (5: OGC-specific persistence/envelope concerns).
* Sequencing — five-step plan respecting the never-wait-for-merge rule.
  Steps 1-4 unblock today against MEOS-API master; step 5 consumes the
  MovFeat-projection PR branch the moment it opens.
* Invariants and open questions for the maintainer.

No code change.  Subsequent PRs execute the steps one at a time.

feat(dispatcher): catalog-driven MEOS-function dispatcher (step 4 fou…

…ndation)

Step 4 of docs/MEOS_API_INGESTION_PLAN.md — the catalog-driven
dispatcher that the 5 'REPLACE' resource modules will delegate to in
follow-up PRs.

mobilityapi/dispatcher.py:

- Loads vendor/meos-api/meos-idl.json at construction; honours an
  explicit catalog_path= for tests.
- Filters to network.exposable functions only when enrichment fields
  are present; otherwise treats every function as exposable.
- FunctionSignature dataclass: name / category / params / return_type
  / decode_per_param / encode_return / description, all populated
  from the catalog (enriched or bare).
- dispatch(function_name, params) -> Any:
  * validates the parameter set against the catalog signature
    (missing or unexpected names raise TypeError)
  * resolves the MEOS function via an injected resolver callable
    (production: getattr(pymeos.functions, name); tests: stub
    registry)
  * invokes it with the validated keyword args
  * returns the result; the caller owns encoding to JSON / WKB

tests/test_dispatcher.py (12 tests, all passing locally):

- catalog load (default path, explicit path, FileNotFoundError)
- FunctionSignature.from_catalog_entry (basic fields, enriched wire
  metadata, fallback when wire absent, non-exposable filtering)
- dispatch contract (resolver invocation, unknown function, missing
  param, unexpected param, default stub resolver)
- integration sanity (the 5 MovFeat dispatch candidates named in the
  ingestion plan are present in the vendored catalog)

What this PR does NOT change:

- Existing hand-written endpoint modules in resource/* remain
  unchanged. The plan's 5 REPLACE candidates migrate to the
  dispatcher module-by-module in follow-up PRs:
  temporal_geom_seq/, temporal_geom_query/{velocity,acceleration,
  distance}, temporal_properties/.
- PyMEOS is not yet a dependency (the dispatcher is resolver-
  agnostic; the production resolver lands when the first endpoint
  migrates).

Stacks on #4 (vendor MEOS-API artefacts) so vendor/meos-api/meos-idl.json
is in the tree.

Merge pull request #2 from MobilityDB/canonicalisation-bundle

Canonicalisation bundle: LICENSE, CI, contributor scaffolding, README rewrite