refactor adapters into modular file structure

config-sqlite: split into repository/ (per entity) + serialization/ (per type) + error.rs
http-api: split into dto/ (per resource) + routes/ (per resource)
tcp-server: split into broadcaster, event_bus, server, error
rss: split parser from adapter, external tests
media: split error, external tests

crates/adapters/tcp-server/src/server.rs

@@ -0,0 +1,38 @@
+use std::sync::Arc;
+use tokio::net::TcpListener;
+use tokio::sync::broadcast;
+use tokio::io::AsyncWriteExt;
+use crate::broadcaster::TcpBroadcaster;
+use crate::error::TcpServerError;
+
+pub async fn run_tcp_server(
+    addr: &str,
+    broadcaster: Arc<TcpBroadcaster>,
+) -> Result<(), TcpServerError> {
+    let listener = TcpListener::bind(addr).await.map_err(TcpServerError::Io)?;
+    println!("TCP server listening on {addr}");
+
+    loop {
+        let (mut socket, peer) = listener.accept().await.map_err(TcpServerError::Io)?;
+        println!("Client connected: {peer}");
+
+        let mut rx = broadcaster.subscribe();
+
+        tokio::spawn(async move {
+            loop {
+                match rx.recv().await {
+                    Ok(frame) => {
+                        if socket.write_all(&frame).await.is_err() {
+                            println!("Client disconnected: {peer}");
+                            break;
+                        }
+                    }
+                    Err(broadcast::error::RecvError::Closed) => break,
+                    Err(broadcast::error::RecvError::Lagged(n)) => {
+                        println!("Client {peer} lagged by {n} messages");
+                    }
+                }
+            }
+        });
+    }
+}