swift: split MoqFFI bindings from the Moq wrapper + Swift-native redesign

[kixelated]

Summary

Applies the Python split (#1551) to Swift, then redesigns the wrapper into a Swift-native API. Two motivations, both the user's:

1. Auto-release MoqFFI via release-plz so consumers float to the latest patch with no wrapper churn, and version the wrapper independently with a registry-gated release workflow.
2. Make the wrapper ergonomic using Swift conventions a generic moq-ffi can't express.

Packaging split

The Swift integration now ships as two SPM packages, each mirrored to its own repo:

Package	Mirror	Versioning	Driven by
MoqFFI (raw bindings + XCFramework)	moq-dev/moq-swift-ffi (new)	lockstep w/ the moq-ffi crate	moq-ffi-v* tag (release-swift-ffi.yml)
Moq (ergonomic wrapper)	moq-dev/moq-swift (existing)	independent (swift/VERSION)	push to main/dev when VERSION is new (release-swift-lib.yml)

• The wrapper pins MoqFFI at .upToNextMinor(from: <crate version>) (substituted from rs/moq-ffi/Cargo.toml at package time, the SPM analog of py's moq-ffi ~= 0.2.x), so a moq-ffi patch reaches consumers with no wrapper release.
• release-swift-lib.yml reads swift/VERSION, checks whether that tag already exists on the mirror (release.sh git-tag-exists, the same registry-gate model release-plz uses), and publishes only when the version is new.
• Local dev keeps one monolithic swift/Package.swift (both targets, path-based XCFramework) so swift test / Xcode are unchanged. The split exists only in the released artifacts, assembled from Package.swift.template (wrapper) and ffi/Package.swift.template (FFI). The FFI module is named MoqFFI in both layouts, so import MoqFFI in the wrapper compiles identically either way.

Scripts split along the same lines: package{,-ffi}.sh, verify{,-ffi}.sh, publish{,-ffi}.sh. Both verify jobs build a throwaway SPM consumer before any mirror push; the wrapper's verify resolves transitively against the published FFI mirror (and skips gracefully if that FFI version isn't mirrored yet, so the bootstrap doesn't deadlock).

Wrapper redesign (swift/Sources/Moq)

• Every stateful FFI handle is wrapped in a de-prefixed, Sendable class: Client, Session, Server, Request, OriginProducer/Consumer, Broadcast*, Track*, Group*, Media*, Audio*, Announced*. MoqFFI's Moq-prefixed classes no longer appear in the public API.
• Consumers conform to AsyncSequence, so for try await frame in mediaConsumer works directly (no .frames adapter); TrackConsumer iterates groups in sequence order with a groupsAsArrived property for arrival order.
• Throwing initializers (BroadcastProducer() throws), Swift-friendly names (connect(to:), Request.accept()/reject(code:), session.publisher/consumer), and the MoqError.isShutdown helper.
• Plain data records/enums are typealias re-exported under de-prefixed names (Frame, Catalog, Audio, Container, …), so new catalog/audio fields track the crate automatically; only new FFI methods need a wrapper method (noted in the Cross-Package Sync table).

Targets the new dev FFI surface (announce, Session.publisher()/consumer()).

Test plan

• just swift check — builds moq-ffi, regenerates bindings, builds the monolithic package, runs swift test (3 tests pass, links against real FFI symbols).
• ./swift/scripts/package.sh dry-run — wrapper tarball stages, REPLACE_FFI_VERSION resolves to the crate version, swift package dump-package parses.
• actionlint clean on both workflows; shfmt/shellcheck clean on all scripts; remark clean on changed docs.
• CI publish-dry-run on both workflows (runs on this PR).
• FFI package/verify full xcframework path (CI macOS; the assembly logic is lifted verbatim from the existing CI-proven package.sh/verify.sh).

Migration notes

• moq-dev/moq-swift-ffi must be created (empty) before the first FFI release; the publish script first-pushes main like the existing one.
• swift/VERSION starts at 0.3.0, opening a new line above the old lockstep 0.2.x wrapper tags (as py's moq-rs did). The FFI mirror starts at the current crate version. Existing consumers pinned from: "0.2.0" on moq-dev/moq-swift will float up to 0.3.0 — the new, breaking API. (Targets dev per Branch Targeting.)

Out of scope

Kotlin and Go still consume moq-ffi-v* lockstep and are untouched; a follow-up can apply the same pattern if this proves out.

(Written by Claude)