feat(sqlite): merge several replicas of one database without conflicts, through plain EF Core

[pal-tamas]

Several replicas of one SQLite database, written independently and merged without conflicts — through
ordinary EF Core. Item 5 of #642.

options.UseSqlite($"Data Source={file};Pooling=False")
       .UseRaskCrdt(o => o.ExtensionPath = crsqlitePath);

protected override void OnModelCreating(ModelBuilder b) => b.ApplyCrdtConventions();
await context.PromoteToCrrsAsync();

var feed = new CrdtChangeFeed(context);
await feed.ApplyChangesAsync(await theirFeed.ReadChangesAsync(sinceDbVersion: watermark));

Merging is per column, not per row

Two devices editing different fields of the same record both keep their work; last-writer-wins
applies only where two devices wrote the same field, which is the case where something genuinely has
to be chosen. That is the whole reason to reach for a CRDT rather than a LastModified column, so it is
what the merge tests assert — not merely that "two writes survive".

CrdtChangeFeed exposes the log with no transport attached. Where the bytes travel is the app's
business, and keeping it that way is what lets the same log work over a bucket, a socket, or nothing at
all. Reading from a watermark makes a sync cost what changed rather than what exists; applying a
change twice is a no-op, which is what makes re-sending safe after an upload whose outcome is unknown,
and why a replica never has to track what its peers already hold.

The package earns its place on three requirements that fail quietly

• The extension is per connection, not per process, and Microsoft.Data.Sqlite pools connections —
  so loading once at startup works until the pool recycles and then silently stops. It is now loaded on
  every open and finalized before every close. Pooling=False is required for the same reason: a handle
  returned to the pool mid-state and handed to somebody else corrupts quietly rather than failing.
• cr-sqlite refuses a NOT NULL column without a default — a peer on an older schema has to be able
  to apply a change that never mentions it — and EF emits exactly that shape for every required
  property. ApplyCrdtConventions() supplies them as expressions, since EF drops a default equal to
  the CLR default: a single bool column would otherwise come out bare and fail alone, reading like a
  cr-sqlite bug rather than an EF one.
• Loading the extension seeds bookkeeping tables, and EnsureCreated treats a database that already
  has tables as provisioned. Creating the schema through a context that loads the extension therefore
  creates nothing at all, and the first symptom is the promotion complaining a table has no primary
  key. Create the schema without the extension, then promote.

A non-SQLite connection is reported rather than skipped: silently not replicating produces an app
that looks like it works and surfaces later as data loss.

The native binary stays the app's to supply via ExtensionPath — cr-sqlite ships one per platform, and
which is right depends on where the app runs rather than on which package it referenced.

Found by the tests, not by review

The convention skipped every value type. Its guard used GetDefaultValue() is not null, which for a
non-nullable value type hands back the boxed CLR default whether or not one was ever configured — so
it reported "already has a default" for every int, bool, Guid and DateTime, leaving only string
and byte[] working. TryGetDefaultValue asks the question that was actually intended.

Verified by mutation rather than trusted for being green: reverting it turns 9 of the 10 per-type
assertions red.

Also removed a dead AddDefaultsForRequiredColumns option — nothing could ever read it, since the
options object lives on the DbContextOptionsBuilder while the convention only sees a ModelBuilder.
Calling or not calling ApplyCrdtConventions() is the switch.

Testing

Merge behaviour runs against the real extension — two replicas exchanging change feeds — gated on
RASK_CRSQLITE_PATH and skipped when the platform binary is absent, matching the CLI's build-gate
shape. Everything reachable without it (conventions per CLR type, options, table resolution, the
connection lifecycle) always runs.

dotnet test tests/Rask.SQLite.Crdt.Tests                              # 24 passed, 4 skipped
RASK_CRSQLITE_PATH=… dotnet test tests/Rask.SQLite.Crdt.Tests         # 28 passed

Local gates: dotnet format clean, dotnet build -warnaserror clean, 320 unit tests, 60 browser
journeys, 26 CLI build-gate tests.

Not in this PR

The browser half. cr-sqlite now links and runs inside a .NET browser-wasm publish, but the build
depends on a hand-pinned Rust nightly plus a post-build rewrite of the archive, which is its own piece
of packaging work rather than something to hide in a csproj.