Quorums: build a tunable-consistency store

Build a minimal N=3 replicated key-value store with per-operation tunable R and W, and produce a test report that empirically demonstrates the R + W > N overlap guarantee plus two of its silent failure modes — a W=1 lost write and a sloppy-quorum stale read.

• Implement N=3 replicas (in-process objects, goroutines, or processes) each storing key -> (value, version/timestamp). A write tags the value with a monotonic version; a read returns the highest version among the replicas it contacts.
• Implement a coordinator with quorum_write(key, value, w) and quorum_read(key, r): the write sends to all replicas but returns success after W acks; the read collects R responses and returns the newest version. R and W are parameters, set per call.
• Add a controllable fault model per replica: mark a node down (drops writes and reads), slow (adds latency), or lagging (silently misses a specific write). Faults are toggled by the test, not random.
• Demonstrate the guarantee: with R=2, W=2 at N=3, write v2, take down one replica, and show every subsequent read returns v2 — assert overlap holds across all single-node failures.
• Demonstrate the W=1 lost write: write v3 at W=1 so only one replica acks, immediately mark that replica down BEFORE it replicates, then read at R=2 and show the store returns the stale v2 (or no v3) — an acknowledged write that survived on zero live replicas.
• Demonstrate sub-overlap drift: with R=1, W=2 (sum 3, not > 3) write v4 to a majority, then issue reads pinned to the one replica that lagged and show intermittent stale v3 reads with no error raised.
• Implement a sloppy quorum: when fewer than W designated replicas are reachable, write to a substitute 'hint-holder' node outside the preference list, tagged with the intended owner. Show a strict R=2 read of the home replicas missing the hinted write during the failure window (stale read), then run hinted handoff on recovery and show the read converging.

• An automated test suite where each scenario (overlap-holds, W=1-lost-write, sub-overlap-drift, sloppy-stale-read, handoff-converges) is a named, repeatable test asserting the exact returned version — not a manual demo.
• A short report table: for each (R, W) pair tried, list R + W, whether R + W > 3, and the observed result (latest / possibly-stale / lost), matching theory to observation.
• The W=1 lost-write test reliably reproduces data loss of an acknowledged write, proving the failure is a configuration consequence and not a bug in your store.
• A one-paragraph write-up explaining, for each failure scenario, which guarantee was forfeited and the exact arithmetic (R + W vs N) or membership change (hint-holder outside read set) that caused it.