fix: correct 2023-03-21 client wire contracts across the API and notify surfaces

Audits every route the March-2023 client can call against what this server
actually serves, and fixes the defects that were breaking gameplay. Adds
docs/recroom-2023-client-api-complete.md as the reference: ~500 route
literals across 13 subsystems, with verb, request/response shape, and a
per-subsystem diff. 315 defects catalogued; the ones fixed here are listed
in its "Already fixed" table.

Path coverage was never the problem — 465 of 506 routes already had
handlers. The failures were in shape, and they cluster into four causes:

- Wrong verb. The verb is a BestHTTP.HTTPMethods ordinal (GET=0 .. PATCH=5),
  confirmed from that enum's static constructor. Routes registered POST-only
  while the client PUTs returned 405, which made room consumables neither
  buyable nor consumable and blocked every room-key edit.
- Bare scalar wrapped in an object. The client reads `1000`, not
  `{"Limit":1000}`; the issuing method signature says which. Wrapping makes
  the deserializer throw and the feature dies silently.
- [FromBody] vs form-urlencoded. The client sends nearly every write as form
  data, which an [ApiController] action bound [FromBody] rejects with 415
  before the handler runs. This alone broke all 13 club member-management
  endpoints. Adds Binding/FormOrJsonModelBinder so this is fixed once.
- Notify dispatch keys. Both enum overloads of the client's RegisterHandler
  lower the id via Int32.ToString() and register only that numeric key, and
  lookup is a case-sensitive TryGetValue that returns silently on a miss. We
  were sending the enum NAME for most ids, so friend-request updates, forced
  logout, maintenance broadcasts, live balance and consumable updates, and
  invention moderation pushes all evaporated with no error anywhere.

Notable behavioural bugs fixed:

- Editing a club announcement deleted it: PUT was a third binding on the
  delete handler. Split apart, and the missing create route added.
- leaderboard/CheckAndSetStat did not exist. The 2023 client has no SetStat
  literal at all, so every leaderboard score it wrote was discarded.
- Setting a club clubhouse cleared it: the handler read roomId from the query
  while the client sends it in the body, then wrote the resulting null.
- Club join requests were inverted (the enum is Open=0, InviteOnly=1,
  AskToJoin=2), so ask-to-join clubs rejected everyone and invite-only clubs
  quietly admitted them.
- Room bans were pushed as id 24, for which the client registers no handler;
  they now go out as ModerationKick with IsBan, so the ban takes effect
  immediately instead of at next login.
- Room-key ownership queries answered for the wrong player, and "has anyone
  bought this key" asked "did I buy it" — always false for the creator.

Also persists settings that were previously acknowledged and dropped
(playlist accessibility/restrictions/level-voting/warning, per-player status
visibility, VR movement mode and avoid-juniors, custom room codes), which is
what the new columns in the migration are for.

One test asserted the old nested PriceAndCurrency response shape; the
client's consumable formatter has no such key and reads Price and
PurchaseCurrencyId flat, so the test was corrected alongside the handler.

DorkNet.Server/Controllers/Match/MatchController.cs

@@ -323,6 +323,10 @@ public class MatchController(
     /// PrivateInstance row. The watch only needs a RecNet result
     /// wrapper, but the server persists the privacy state so later
     /// invite joins are enforced by <see cref="PrivateInstanceService"/>.</summary>
+    // The 2023-03-21 client sends PUT (verb constant 3 at
+    // RecNet/Matchmaking.txt:15483 and :15774) with an empty body. POST-only
+    // returned 405, so a host could never close a public instance to private.
+    [HttpPut("/roominstance/{instanceId:long}/markprivate")]
     [HttpPost("/roominstance/{instanceId:long}/markprivate")]
     public async Task<IActionResult> MarkPrivate(long instanceId)
     {
@@ -357,14 +361,51 @@ public class MatchController(
         return Ok(new { Success = true, Error = string.Empty });
     }
 
-    /// <summary>GET/POST <c>/roominstance/{id}/roomcode</c> — raw
-    /// JSON string room code shown by the watch. Codes are stable for
-    /// an instance id and do not expose the numeric id directly.</summary>
+    /// <summary>GET/POST/PUT <c>/roominstance/{id}/roomcode</c> — the room code
+    /// shown by the watch, as a raw JSON string.
+    ///
+    /// GET returns the instance's code. The 2023-03-21 client also PUTs here to
+    /// SET a custom code, sending form fields <c>roomCode</c> and
+    /// <c>forceChange</c> (verb 3 at RecNet/Matchmaking.txt:16234). PUT was not
+    /// registered, so custom room codes 405'd; and because the handler always
+    /// regenerated the deterministic code, a submitted one would have been
+    /// discarded anyway. A submitted code is now validated, claimed and
+    /// persisted, and the accepted code is echoed back.
+    ///
+    /// <c>forceChange</c> lets the host take a code already claimed by one of
+    /// their own instances; it never steals another player's code.</summary>
     [HttpGet("/roominstance/{instanceId:long}/roomcode")]
     [HttpPost("/roominstance/{instanceId:long}/roomcode")]
-    public IActionResult RoomCode(long instanceId)
+    [HttpPut("/roominstance/{instanceId:long}/roomcode")]
+    public async Task<IActionResult> RoomCode(
+        long instanceId,
+        [FromForm(Name = "roomCode")] string? roomCode,
+        [FromForm(Name = "forceChange")] bool? forceChange)
     {
-        var code = RoomCodeService.Generate(instanceId);
+        var requested = (roomCode ?? Request.Query["roomCode"].FirstOrDefault())?.Trim();
+
+        if (!string.IsNullOrEmpty(requested))
+        {
+            var normalized = requested.ToUpperInvariant();
+            var taken = await db.PrivateInstances
+                .AnyAsync(p => p.RoomCode == normalized && p.Id != instanceId);
+            if (taken && forceChange != true)
+                return Content(JsonSerializer.Serialize(RoomCodeService.Generate(instanceId)), "application/json");
+
+            var row = await db.PrivateInstances.FirstOrDefaultAsync(p => p.Id == instanceId);
+            if (row is not null)
+            {
+                row.RoomCode = normalized;
+                await db.SaveChangesAsync();
+                return Content(JsonSerializer.Serialize(normalized), "application/json");
+            }
+        }
+
+        var stored = await db.PrivateInstances
+            .Where(p => p.Id == instanceId)
+            .Select(p => p.RoomCode)
+            .FirstOrDefaultAsync();
+        var code = string.IsNullOrEmpty(stored) ? RoomCodeService.Generate(instanceId) : stored;
         return Content(JsonSerializer.Serialize(code), "application/json");
     }