fix(market): make the transfer market work end-to-end (live-verified)

Four defects found by driving a real FIFA 17 client. Each was independently
sufficient to break listing, so all four had to go:

1. Every owned card was shaped `untradeable: true` (adapter item.rs), so the
   client greyed out "Place/List on Transfer Market" for the whole club. Owned
   and pack-pulled cards are TRADEABLE in FIFA 17; the oracle forces this off
   for owned copies too (item_def keeps `true`; instances do not).

2. `POST /auctionhouse` required `itemData.resourceId`, which the client's
   FutISStart body never sends (the oracle lists by wire id ALONE). Missing it,
   the handler fail-closed and returned 200 while persisting NOTHING. It now
   resolves server-side: wire id -> Core owned instance -> its card_id (minted on
   a synthetic buy) + FIFA resourceId (the auction record). This also enforces
   that a listing can only name a card the club actually owns.

3. An auction record's `itemData` was a 4-field STUB, so the Transfer List had a
   row the client could not draw -> "1 item listed" but no visible sale. A
   listing now persists a full shaped-card SNAPSHOT (new `listings.item_json`,
   additive migration) built by the same `shape_item` shaper `/club` and the
   squad projection use, so the auction card renders identically to the club
   card. The seller's own pile stamps `itemState: listFS`; market search keeps
   `forSale` (the oracle distinguishes these).

4. `/tradePile/counts` shared a handler with `/tradePile`. They are DIFFERENT
   deserializers: `/counts` is FutGetAuctionCount, five scalar ints
   (count/maxAuctionsAllowed/offered/selling/sold) that it reads and skips
   everything else. Served the `auctionInfo` body it left every count at 0, so
   the Transfer List screen showed no active sale while the hub tile showed one.
   New Route::MarketCounts, classified BEFORE the base tradePile matcher (which
   also accepts the /counts path).

Also: a listed card no longer appears in the club. `/club` and the hub's
`clubPlayers` now exclude the transfer pile. Pile membership is host-owned state
Core cannot filter on, so when anything is hidden `/club` reuses the existing
local-filter path (the one `rare=SP` already needed) and paginates the
club-visible set -- letting Core paginate would return short pages. With nothing
hidden the fast Core-paginated path is untouched, and only an EXPLICIT non-club
pile hides a card, so no-pile-row items still default to the club.

Fixed 5 pre-existing test fixtures across 4 targets that listed FABRICATED wire
ids -- only "valid" because the old handler skipped the ownership check.

Tests: 14 targets green + clippy clean, incl. new coverage for the 5-int tally
(asserting it must NOT carry auctionInfo), the full-card snapshot + listFS, and
club pile-exclusion with full-width pagination. The differential test against the
live Python oracle passes.

Verified live on prod: listed=true with a 21-field snapshot; counts
{count:1,selling:1,maxAuctionsAllowed:100}; tradePile renders the 94-rated card;
clubPlayers 1966 -> 1961 (exactly the 5 trade-pile items); listed wire absent
from the club page. Operator confirmed the card is visible in the Transfer List.

openfut-utas-host/tests/host_test.rs

@@ -13,10 +13,10 @@ use openfut_adapter_fifa17::fut::club_response::{CoreOwnedItem, ItemIdentityReso
 use openfut_adapter_fifa17::fut::entities::Fifa17Entities;
 use openfut_identity::JsonIdentityStore;
 use openfut_utas_host::{
-    classify, handle_put_squad, handle_squad_active, handle_squad_list, handle_user_mass_info,
-    read_request, CoreAccess, CoreError, CoreExtState, CorePage, CoreReplaceRequest,
-    CoreReplaceResult, CoreSquadRead, CoreSquadSlot, Fifa17IdentityResolver, HttpCoreClient,
-    PassClient, Route, Server, SquadDeps,
+    classify, handle_club, handle_put_squad, handle_squad_active, handle_squad_list,
+    handle_user_mass_info, read_request, ClubDeps, CoreAccess, CoreError, CoreExtState, CorePage,
+    CoreReplaceRequest, CoreReplaceResult, CoreSquadRead, CoreSquadSlot, Fifa17IdentityResolver,
+    HttpCoreClient, PassClient, Route, Server, SquadDeps,
 };
 use parking_lot::Mutex;
 use serde_json::Value;
@@ -279,6 +279,86 @@ fn build_server(
     )
 }
 
+/// A real identity resolver over a `card_id -> asset_id` map (same construction
+/// `build_server` uses), for tests that call `handle_club` directly.
+fn resolver_for(cards: &[(&str, u32)]) -> Arc<Fifa17IdentityResolver> {
+    let entries: Vec<String> = cards
+        .iter()
+        .map(|(id, asset)| format!("\"{id}\":{{\"asset_id\":{asset}}}"))
+        .collect();
+    let doc = format!(
+        "{{\"schema_version\":1,\"game\":\"fifa17\",\"cards\":{{{}}}}}",
+        entries.join(",")
+    );
+    let catalog = Fifa17CardCatalog::from_json_str(&doc).unwrap();
+    let store = JsonIdentityStore::open(unique_store_path()).unwrap();
+    Arc::new(Fifa17IdentityResolver::new(catalog, Arc::new(store)))
+}
+
+/// A card on the transfer list has LEFT the club: `/club` must not show it, and
+/// pagination must run over the CLUB-VISIBLE set (never Core's unfiltered page,
+/// which would hand back short pages).
+#[test]
+fn club_excludes_transfer_pile_items_and_paginates_the_visible_set() {
+    let core = Arc::new(FakeCore::new(
+        vec![
+            item("oc1", "card_a", 86, "CDM", "Argentina", "Premier League", "Chelsea"),
+            item("oc2", "card_b", 85, "ST", "Argentina", "Premier League", "Chelsea"),
+            item("oc3", "card_c", 84, "CB", "Argentina", "Premier League", "Chelsea"),
+        ],
+        3,
+    ));
+    let resolver = resolver_for(&[("card_a", 20801), ("card_b", 20802), ("card_c", 20803)]);
+    let ents = entities();
+
+    // oc2 is listed on the transfer market.
+    let hidden: std::collections::HashSet<String> = ["oc2".to_string()].into_iter().collect();
+    let deps = ClubDeps {
+        core: core.as_ref(),
+        entities: &ents,
+        assets: resolver.as_ref(),
+        hidden: &hidden,
+    };
+    let (resp, log) = handle_club("", &deps);
+    let v: Value = serde_json::from_slice(&resp.body).unwrap();
+    let assets: Vec<i64> = v["itemData"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|i| i["assetId"].as_i64().unwrap())
+        .collect();
+    assert_eq!(
+        assets,
+        vec![20801, 20803],
+        "the transfer-pile card is not in the club"
+    );
+    assert_eq!(log.total, 2, "total is the club-visible count");
+
+    // A page of 2 over a 2-item visible set is FULL — not short because a hidden
+    // item consumed a slot.
+    let (resp2, log2) = handle_club("count=2", &deps);
+    let v2: Value = serde_json::from_slice(&resp2.body).unwrap();
+    assert_eq!(
+        v2["itemData"].as_array().unwrap().len(),
+        2,
+        "full-width page from the visible set"
+    );
+    assert_eq!(log2.total, 2);
+
+    // Nothing hidden → the fast Core-paginated path, all three visible.
+    let none: std::collections::HashSet<String> = std::collections::HashSet::new();
+    let deps_all = ClubDeps {
+        core: core.as_ref(),
+        entities: &ents,
+        assets: resolver.as_ref(),
+        hidden: &none,
+    };
+    let (resp3, log3) = handle_club("", &deps_all);
+    let v3: Value = serde_json::from_slice(&resp3.body).unwrap();
+    assert_eq!(v3["itemData"].as_array().unwrap().len(), 3);
+    assert_eq!(log3.total, 3);
+}
+
 // ── /club served from Core ─────────────────────────────────────────────────
 
 #[test]