feat(bezpieczenstwo): szyfrowanie lacz miedzy warstwami AES-256-GCM (PRE-16)

Warstwy rozmawialy ze soba jawnym tekstem wewnatrz klastra. Token
miedzywarstwowy (LOG-32) mowil KTO pyta, ale nie ukrywal CZEGO dotyczy
odpowiedz — a plyna nia surowe wiersze oryginalnych baz interpretacyjnych,
czyli rdzen produktu. Kto podsluchal ruch wewnatrz sieci (drugi pod, mirror
portu na switchu, zrzut z wezla), mial je w calosci.

Nowy modul link_crypto (kopia w kazdej z trzech uslug — nie maja wspolnej
biblioteki; test pilnuje, ze kopie sa identyczne):
- AES-256-GCM na ciele kazdego zadania i odpowiedzi. GCM daje poufnosc I
  uwierzytelnienie naraz, wiec nie ma wariantu „zaszyfrowane, ale podatne na
  modyfikacje".
- DWA niezalezne klucze, po jednym na pare rozmowcow (prezentacja-logika,
  logika-dane). Przejecie klucza prezentacji nie otwiera warstwy danych, gdzie
  leza cale bazy. Z kazdego klucza lacza HKDF wyprowadza osobne podklucze na
  kierunek, wiec zadanie i odpowiedz nigdy nie szyfruja sie tym samym kluczem.
- Do materialu uwierzytelnianego (AAD) wchodza kierunek, sciezka, znacznik
  czasu i numer ramki — wiec ramki nie da sie przekleic na inny endpoint,
  odtworzyc po czasie (okno MAX_SKEW) ani przestawic w strumieniu.
- Strona serwerowa to czyste ASGI: podmienia cialo zanim zobaczy je FastAPI
  i przepuszcza odpowiedz strumieniowa kawalek po kawalku (okno postepu dziala
  dalej). Fail-closed: przy ustawionym kluczu jawne zadanie dostaje odmowe.

Najgrozniejszy blad wyszedl dopiero z PODSLUCHU prawdziwego gniazda, nie
z testow: klient BEZ klucza wysylal pytanie jawnym tekstem, ZANIM serwer zdazyl
odmowic. Odpowiedz byla chroniona, zapytanie juz nie — a to wlasnie ono niesie
sygnifikatory. Stad LINK_ENCRYPTION_REQUIRED: klient nie wysyla niczego, a
usluga nie wstaje, jesli klucza brak. Ta sama zasada co przy sekrecie logowania
— wolimy pod w CrashLoop niz usluge, ktora wstala i po cichu nie chroni niczego.

Klient prezentacji przepuszczony przez jeden punkt `_post()`: dopoki kazda
metoda skladala zadanie sama, dolozenie nowej znaczylo, ze latwo zapomniec
o tokenie albo kluczu (401 wyszedl juz raz dopiero na produkcji). Test
strukturalny rozszerzony: kazde wyjscie w dol musi miec i token, i klucz lacza,
a surowe httpx wolno tylko na sciezkach wyjetych spod szyfrowania (/health).

Weryfikacja:
- 23 testy link_crypto, w tym dowod, ze tajny opis NIE wystepuje w bajtach
  lecacych po sieci, oraz odrzucenie: obcego klucza, przestawionego bitu,
  przekleconej sciezki, przestawionej ramki, przeterminowanej koperty, urwanego
  strumienia i absurdalnej dlugosci ramki.
- E2E na prawdziwym uvicornie z proxy zrzucajacym gniazdo do pliku: przy
  wlaczonym wymaganiu tresci baz NIE MA na kablu (grep = 0) w obie strony;
  bez klucza / ze zlym kluczem — odmowa; klucz jednej pary nie otwiera drugiej.
- Calosc: logika 200 passed/1 skipped, prezentacja 25 passed.

docs/wdrozenie-pre16.md: instrukcja krok po kroku (klucze -> cert-manager ->
DNS -> merge aplikacji -> merge manifestow -> zaufanie CA -> weryfikacja),
z uzasadnieniem kolejnosci i tabela diagnostyki.

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

services/logic/app/clients/data_client.py

@@ -10,6 +10,7 @@ from typing import Any
 
 import httpx
 
+from app import link_crypto
 from app.config import settings
 
 
@@ -19,6 +20,13 @@ def _auth_headers() -> dict[str, str]:
     return {"X-Astrololo-Token": token} if token else {}
 
 
+def _link() -> link_crypto.Link | None:
+    """Klucz łącza logika↔dane. Czytany przy każdym wywołaniu, bo konfiguracja
+    może się zmienić bez restartu procesu (testy, podmiana sekretu)."""
+    key = link_crypto.key_from_env(link_crypto.ENV_LOGIC_DATA)
+    return link_crypto.Link(key) if key else None
+
+
 class DataClient:
     def __init__(self, base_url: str | None = None) -> None:
         self.base_url = (base_url or settings.data_url).rstrip("/")
@@ -33,11 +41,13 @@ class DataClient:
     ) -> dict[str, Any]:
         payload = {"key": key, "value": value, "exact": exact, "limit": limit, "fields": fields}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
-            r = client.post(f"{self.base_url}/search", json=payload, headers=_auth_headers())
-            r.raise_for_status()
-            return r.json()
+            return link_crypto.call_json(client, "POST", f"{self.base_url}/search",
+                                         payload=payload, headers=_auth_headers(),
+                                         link=_link())
 
     def health(self) -> dict[str, Any]:
+        # /health celowo poza szyfrowaniem — pukają tu sondy k8s, które klucza
+        # nie mają, a nie przechodzi tędy nic z baz.
         with httpx.Client(timeout=settings.http_timeout) as client:
             r = client.get(f"{self.base_url}/health", headers=_auth_headers())
             r.raise_for_status()