Decouple all cross-app service calls to HTTP endpoints

Replace every direct cross-app services.* call with HTTP-based
communication: call_action() for writes, fetch_data() for reads.
Each app now registers only its own domain service.

Infrastructure:
- shared/infrastructure/actions.py — POST client for /internal/actions/
- shared/infrastructure/data_client.py — GET client for /internal/data/
- shared/contracts/dtos.py — dto_to_dict/dto_from_dict serialization

Action endpoints (writes):
- events: 8 handlers (ticket adjust, claim/confirm, toggle, adopt)
- market: 2 handlers (create/soft-delete marketplace)
- cart: 1 handler (adopt cart for user)

Data endpoints (reads):
- blog: 4 (post-by-slug/id, posts-by-ids, search-posts)
- events: 10 (pending entries/tickets, entries/tickets for page/order,
  entry-ids, associated-entries, calendars, visible-entries-for-period)
- market: 1 (marketplaces-for-container)
- cart: 1 (cart-summary)

Service registration cleanup:
- blog→blog+federation, events→calendar+federation,
  market→market+federation, cart→cart only,
  federation→federation only, account→nothing
- Stubs reduced to minimal StubFederationService

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

shared/services/cart_impl.py

@@ -13,7 +13,6 @@ from sqlalchemy.orm import selectinload
 
 from shared.models.market import CartItem
 from shared.models.market_place import MarketPlace
-from shared.models.calendars import CalendarEntry, Calendar
 from shared.contracts.dtos import CartItemDTO, CartSummaryDTO
 
 
@@ -39,13 +38,16 @@ class SqlCartService:
         page_slug: str | None = None,
     ) -> CartSummaryDTO:
         """Build a lightweight cart summary for the current identity."""
-        # Resolve page filter
+        from shared.infrastructure.data_client import fetch_data
+        from shared.contracts.dtos import CalendarEntryDTO, TicketDTO, dto_from_dict
+
+        # Resolve page filter via blog data endpoint
         page_post_id: int | None = None
         if page_slug:
-            from shared.services.registry import services
-            post = await services.blog.get_post_by_slug(session, page_slug)
-            if post and post.is_page:
-                page_post_id = post.id
+            post = await fetch_data("blog", "post-by-slug",
+                                    params={"slug": page_slug}, required=False)
+            if post and post.get("is_page"):
+                page_post_id = post["id"]
 
         # --- product cart ---
         cart_q = select(CartItem).where(CartItem.deleted_at.is_(None))
@@ -75,37 +77,34 @@ class SqlCartService:
             if ci.product and (ci.product.special_price or ci.product.regular_price)
         )
 
-        # --- calendar entries ---
-        from shared.services.registry import services
+        # --- calendar entries via events data endpoint ---
+        cal_params: dict = {}
+        if user_id is not None:
+            cal_params["user_id"] = user_id
+        if session_id is not None:
+            cal_params["session_id"] = session_id
+
         if page_post_id is not None:
-            cal_entries = await services.calendar.entries_for_page(
-                session, page_post_id,
-                user_id=user_id,
-                session_id=session_id,
-            )
+            cal_params["page_id"] = page_post_id
+            raw_entries = await fetch_data("events", "entries-for-page",
+                                           params=cal_params, required=False) or []
         else:
-            cal_entries = await services.calendar.pending_entries(
-                session,
-                user_id=user_id,
-                session_id=session_id,
-            )
+            raw_entries = await fetch_data("events", "pending-entries",
+                                           params=cal_params, required=False) or []
+        cal_entries = [dto_from_dict(CalendarEntryDTO, e) for e in raw_entries]
 
         calendar_count = len(cal_entries)
         calendar_total = sum(Decimal(str(e.cost or 0)) for e in cal_entries if e.cost is not None)
 
-        # --- tickets ---
+        # --- tickets via events data endpoint ---
         if page_post_id is not None:
-            tickets = await services.calendar.tickets_for_page(
-                session, page_post_id,
-                user_id=user_id,
-                session_id=session_id,
-            )
+            raw_tickets = await fetch_data("events", "tickets-for-page",
+                                           params=cal_params, required=False) or []
         else:
-            tickets = await services.calendar.pending_tickets(
-                session,
-                user_id=user_id,
-                session_id=session_id,
-            )
+            tk_params = {k: v for k, v in cal_params.items() if k != "page_id"}
+            raw_tickets = await fetch_data("events", "pending-tickets",
+                                           params=tk_params, required=False) or []
+        tickets = [dto_from_dict(TicketDTO, t) for t in raw_tickets]
 
         ticket_count = len(tickets)
         ticket_total = sum(Decimal(str(t.price or 0)) for t in tickets)