arch: split ConfigRepository, extract polling, consolidate conversions, decouple protocol

- Value↔JSON: From impls on domain Value behind `json` feature, delete 4 duplicate converters
- ConfigRepository split into ConfigRepository (12), UserRepository (3), WidgetStateCache (2)
- polling orchestration moved from bootstrap to application::polling_service
- WidgetRenderer in client-domain owns scroll/cache, both clients use it
- network loop consolidated into client-application::run_connection_loop
- protocol crate drops domain dep, Wire↔Domain conversions move to adapters

crates/client-esp32/src/tasks/network.rs

@@ -1,56 +1,26 @@
 use std::sync::mpsc;
 use std::thread;
-use client_domain::NetworkPort;
-use protocol::decode_server_message;
+use client_application::run_connection_loop;
 use super::RenderEvent;
 use crate::config::{NET_THREAD_STACK_SIZE, NET_POLL_INTERVAL, NET_RECONNECT_DELAY};
 use crate::adapters::network::Esp32Network;
-use log::*;
 
 pub fn spawn(server_addr: String, tx: mpsc::Sender<RenderEvent>) {
     thread::Builder::new()
         .stack_size(NET_THREAD_STACK_SIZE)
         .name("net".into())
-        .spawn(move || run(server_addr, tx))
+        .spawn(move || {
+            let mut net = Esp32Network::new();
+            let tx_msg = tx.clone();
+            let tx_status = tx.clone();
+            run_connection_loop(
+                &mut net,
+                &server_addr,
+                NET_POLL_INTERVAL,
+                NET_RECONNECT_DELAY,
+                move |msg| { let _ = tx_msg.send(RenderEvent::Server(msg)); },
+                move |connected| { let _ = tx_status.send(RenderEvent::ConnectionStatus(connected)); },
+            );
+        })
         .expect("failed to spawn network thread");
 }
-
-fn run(server_addr: String, tx: mpsc::Sender<RenderEvent>) {
-    let mut net = Esp32Network::new();
-
-    loop {
-        if !net.is_connected() {
-            info!("Connecting to server {server_addr}...");
-            match net.connect(&server_addr) {
-                Ok(()) => {
-                    info!("Server connected");
-                    let _ = tx.send(RenderEvent::ConnectionStatus(true));
-                }
-                Err(e) => {
-                    error!("Connection failed: {e}, retrying...");
-                    let _ = tx.send(RenderEvent::ConnectionStatus(false));
-                    thread::sleep(NET_RECONNECT_DELAY);
-                    continue;
-                }
-            }
-        }
-
-        match net.receive() {
-            Ok(Some(payload)) => {
-                match decode_server_message(&payload) {
-                    Ok(msg) => { let _ = tx.send(RenderEvent::Server(msg)); }
-                    Err(e) => error!("Decode error: {e}"),
-                }
-            }
-            Ok(None) => {
-                thread::sleep(NET_POLL_INTERVAL);
-            }
-            Err(e) => {
-                error!("Receive error: {e}, reconnecting...");
-                let _ = net.disconnect();
-                let _ = tx.send(RenderEvent::ConnectionStatus(false));
-                thread::sleep(NET_RECONNECT_DELAY);
-            }
-        }
-    }
-}