feat: Initialize telecom platform with core services and infrastructure

- Add Go-based API server and carrier connector services
- Add Rust-based charging engine and packet gateway services
- Add Docker Compose configuration for local development
- Add comprehensive documentation (API, Architecture, Deployment)
- Add development scripts for Redis, MongoDB, and environment setup
- Add workspace configuration for Go modules and pnpm
- Remove unnecessary documentation files from web-dashboard
- Add project build configuration (Makefile, Cargo.toml)

This commit establishes the foundational microservices architecture for the sovereign Telecom-as-a-Service platform.

apps/packet-gateway/src/main.rs

@@ -0,0 +1,79 @@
+use anyhow::{Context, Result};
+use clap::Parser;
+use redis::AsyncCommands;
+use tokio::time::{interval, Duration};
+use tracing::{info, warn, error};
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// Network interface to attach XDP program
+    #[arg(short, long, default_value = "eth0")]
+    interface: String,
+
+    /// Redis connection URL
+    #[arg(short, long, default_value = "redis://127.0.0.1/")]
+    redis_url: String,
+
+    /// Stats sync interval in seconds
+    #[arg(short, long, default_value = "1")]
+    sync_interval: u64,
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize tracing
+    tracing_subscriber::fmt()
+        .with_target(false)
+        .compact()
+        .init();
+
+    dotenv::dotenv().ok();
+    let args = Args::parse();
+
+    info!("Starting Packet Gateway");
+    info!("Interface: {}", args.interface);
+    info!("Redis URL: {}", args.redis_url);
+
+    // NOTE: This is a simplified version
+    // For full eBPF implementation, you need:
+    // 1. Compile eBPF program with aya-bpf
+    // 2. Load and attach XDP program
+    // 3. Access eBPF maps for packet stats and credit control
+    
+    // Connect to Redis
+    let redis_client = redis::Client::open(args.redis_url.as_str())?;
+    let mut redis_conn = redis_client.get_multiplexed_async_connection().await?;
+    
+    // Test connection
+    let _: () = redis::cmd("PING").query_async(&mut redis_conn).await?;
+    info!("Connected to Redis successfully");
+
+    // Simulate packet processing loop
+    // In production, this would read from eBPF maps
+    let mut ticker = interval(Duration::from_secs(args.sync_interval));
+    
+    info!("Packet gateway running. Press Ctrl+C to exit.");
+    
+    loop {
+        ticker.tick().await;
+        
+        // Simulate updating packet statistics to Redis
+        // In real implementation, read from eBPF map
+        let test_ip = "10.0.0.1";
+        let test_bytes: u64 = 1024 * 1024; // 1 MB
+        
+        let key = format!("usage:{}", test_ip);
+        let _: () = redis_conn.set_ex(&key, test_bytes, 3600).await?;
+        
+        info!("Updated usage for {}: {} bytes", test_ip, test_bytes);
+        
+        // Check credit status
+        let credit_key = format!("credit:{}", test_ip);
+        let credit: i64 = redis_conn.get(&credit_key).await.unwrap_or(0);
+        
+        if credit <= 0 {
+            warn!("User {} has no credit - would block traffic in eBPF", test_ip);
+        }
+    }
+}