fix(market): returning an item to the club ends its auction; close the panel probe

CLOSES the active-own-auction Actions-panel investigation. Live client plus the RE
corpus plus historical FUT behaviour all agree: an active auction is COMMITTED until
sale or expiry and is not seller-actionable, while an expired unsold item becomes
actionable (relist / return to club). Every observation fits that lifecycle --
active+frozen expires was non-selectable, expired was selectable and relisted fine,
relisting made it active and non-selectable again, and the client never emits a
cancel. Documented with confidence tags, and the dead ends are named so they are not
retried: MAY_BE_REMOVED is a constant 1, and the eight-flag array is the CLUB-CARD
menu with no auction-cancellation flag in it.

Implements the return-to-club transition that closure exposes. A pile move to `club`
now cancels any ACTIVE listing on that item, because the auction that put the card
in the pile has to end with it. Otherwise the pile reads `club` while the row stays
`active`, so the card is filtered out of /club (exclusion keys on active listings)
AND still rendered in the Transfer List: the move appears to do nothing. This is the
same limbo class as the earlier pile-vs-listing bug, found by reasoning about the
transition rather than by another live failure.

Scoped to `active` only: a `reserved` row is mid-sale and a `sold` row is already
gone, so cancelling either would let one card be both sold and returned. Two tests
cover exactly that boundary.

338 tests pass, 0 failed, clippy clean.

openfut-utas-host/src/lib.rs

@@ -2300,11 +2300,21 @@ impl Server {
             }
             EconomyRoute::MatchEnd => handle_match_end(svc.econ.as_ref(), body),
             EconomyRoute::MoveItems => {
-                let (bridge, piles, resolver) =
-                    (svc.bridge.clone(), svc.piles.clone(), self.resolver.clone());
+                let (bridge, piles, resolver, market) = (
+                    svc.bridge.clone(),
+                    svc.piles.clone(),
+                    self.resolver.clone(),
+                    svc.market.clone(),
+                );
                 let body = body.to_vec();
                 bridge.block_on(async move {
-                    crate::market::handle_move_items(&body, resolver.as_ref(), piles.as_ref()).await
+                    crate::market::handle_move_items(
+                        &body,
+                        resolver.as_ref(),
+                        piles.as_ref(),
+                        market.as_ref(),
+                    )
+                    .await
                 })
             }
             EconomyRoute::MarketList => {