feat(fifa17): route match completion to Core exactly-once economy

Adapter: new fut/match_wire.rs owns the FIFA17 match wire — endReason
enum -> canonical result token (win/draw/loss/dnf/no_contest), match-end
payload parse (goals from myMatchStats[0], omitted on DNF/QUIT), and the
reward-response projection (only reversed fields; never bidTokens/
qualifiedChampionEventId). Match logic removed from economy_policy.rs
(kept pack/fee); registered match_wire in fut/mod.rs.

Host: handle_match_end now applies the match to Core's authoritative
complete_match (POST /matches/complete) fail-closed — any Core error is a
503, never a Python fallback — and renders Core's authoritative coins.
Per-match identity from matchReportId or a body fingerprint keys Core's
durable idempotency. New CoreEconomy::complete_match transport +
CoreMatchCompletion/CoreMatchReceipt.

Tests: adapter endReason/parse/projection; host shaping, fail-closed,
malformed, identity dedupe; integration replay + rebased balance chains
(match now also grants XP/level-up/achievement coins).

openfut-utas-host/tests/economy_concurrency.rs

@@ -484,20 +484,39 @@ fn case_d_two_market_buyers(h: &Harness) -> String {
     )
 }
 
-/// E: match REWARD + Store BUY concurrently → final balance is one legal
-/// serialization (no lost update). Reward (+400) and buy (−400) commute, so the
-/// final balance must equal the start exactly.
+/// E: match REWARD + Store BUY concurrently → one legal serialization (no lost
+/// update). The two commute, so the final balance must equal exactly one serial
+/// outcome: the match's reported post-credit balance (`allCoins`), or that minus
+/// the buy's debit — never a torn value from a clobbered write. Amount-agnostic,
+/// so it holds even when a WIN also triggers an XP level-up bonus.
 fn case_e_reward_and_buy(h: &Harness) -> String {
+    // Measure the store BUY's deterministic debit once.
+    set_balance(&h.client, 50_000);
+    let pre_probe = h.client.balance().unwrap();
+    let probe = fire(
+        &h.server,
+        vec![(
+            "PUT",
+            "/ut/game/fifa17/store/transaction".into(),
+            b"{\"packId\":1}".to_vec(),
+        )],
+    );
+    assert_eq!(probe[0].status, 200, "probe buy ok");
+    let buy_debit = pre_probe - h.client.balance().unwrap();
+    assert!(buy_debit > 0, "store buy must debit a positive price");
+
     let start = 8_000i64;
-    for _ in 0..ITERS {
+    for i in 0..ITERS {
         set_balance(&h.client, start);
+        // A DISTINCT match per iteration (unique matchReportId) so the
+        // exactly-once reward applies every time.
         let rs = fire(
             &h.server,
             vec![
                 (
                     "POST",
                     "/ut/delete/game/fifa17/match".into(),
-                    b"{\"endReason\":\"WIN\"}".to_vec(),
+                    format!("{{\"matchReportId\":{i},\"endReason\":\"WIN\"}}").into_bytes(),
                 ),
                 (
                     "PUT",
@@ -507,13 +526,15 @@ fn case_e_reward_and_buy(h: &Harness) -> String {
             ],
         );
         assert!(rs.iter().all(|r| r.status == 200), "both ops succeed");
-        assert_eq!(
-            h.client.balance().unwrap(),
-            start,
-            "reward(+400) and buy(-400) both applied: no lost update"
+        let all = bj(&rs[0])["allCoins"].as_i64().expect("allCoins");
+        let after = h.client.balance().unwrap();
+        // Both writers serialized: `after` is one of the two legal orderings.
+        assert!(
+            after == all || after == all - buy_debit,
+            "no lost update: after={after}, match allCoins={all}, buy_debit={buy_debit}"
         );
     }
-    format!("E reward+buy: {ITERS} iters, final==start ({start}) every time (no lost update)")
+    format!("E reward+buy: {ITERS} iters, no lost update (buy_debit={buy_debit})")
 }
 
 /// F: MOVE + QUICK-SELL of the same item → one coherent final state (item sold