Remove Tailscale and connection type complexity

Simplifies host connection configuration by removing tailscale_ip field,
connection_type preferences, and fallback retry logic. Now uses only the
ip field or hostname as fallback. Eliminates blocking TCP connectivity
tests that interfered with heartbeat processing.

This resolves intermittent host lost/found issues by removing the
connection retry timeouts that blocked the ZMQ message processing loop.

dashboard/src/config/mod.rs

@@ -31,76 +31,15 @@ pub struct HostDetails {
     pub mac_address: Option<String>,
     /// Primary IP address (local network)
     pub ip: Option<String>,
-    /// Tailscale network IP address
-    pub tailscale_ip: Option<String>,
-    /// Preferred connection type: "local", "tailscale", or "auto" (fallback)
-    #[serde(default = "default_connection_type")]
-    pub connection_type: String,
 }
 
-fn default_connection_type() -> String {
-    "auto".to_string()
-}
 
 impl HostDetails {
-    /// Get the preferred IP address for connection based on connection_type
+    /// Get the IP address for connection (uses ip field or hostname as fallback)
     pub fn get_connection_ip(&self, hostname: &str) -> String {
-        match self.connection_type.as_str() {
-            "tailscale" => {
-                if let Some(ref ts_ip) = self.tailscale_ip {
-                    ts_ip.clone()
-                } else {
-                    // Fallback to local IP or hostname
-                    self.ip.as_ref().unwrap_or(&hostname.to_string()).clone()
-                }
-            }
-            "local" => {
-                if let Some(ref local_ip) = self.ip {
-                    local_ip.clone()
-                } else {
-                    hostname.to_string()
-                }
-            }
-            "auto" | _ => {
-                // Try local first, then tailscale, then hostname
-                if let Some(ref local_ip) = self.ip {
-                    local_ip.clone()
-                } else if let Some(ref ts_ip) = self.tailscale_ip {
-                    ts_ip.clone()
-                } else {
-                    hostname.to_string()
-                }
-            }
-        }
+        self.ip.as_ref().unwrap_or(&hostname.to_string()).clone()
     }
 
-    /// Get fallback IP addresses for connection retry
-    pub fn get_fallback_ips(&self, hostname: &str) -> Vec<String> {
-        let mut fallbacks = Vec::new();
-        
-        // Add all available IPs except the primary one
-        let primary = self.get_connection_ip(hostname);
-        
-        // Add fallbacks in priority order: local first, then tailscale
-        if let Some(ref local_ip) = self.ip {
-            if local_ip != &primary {
-                fallbacks.push(local_ip.clone());
-            }
-        }
-        
-        if let Some(ref ts_ip) = self.tailscale_ip {
-            if ts_ip != &primary {
-                fallbacks.push(ts_ip.clone());
-            }
-        }
-        
-        // Always include hostname as final fallback if not already primary
-        if hostname != primary {
-            fallbacks.push(hostname.to_string());
-        }
-        
-        fallbacks
-    }
 }
 
 /// System configuration