refactor(auth,etcd): reduce nesting depth to comply with 3-level max

- service/auth/login.rs: extract auth_find_user() helper combining
  username + email lookup, reducing login flow from 5 levels to 3
- etcd/register.rs: extract run_keep_alive_stream() and
  renew_lease_and_reregister() from spawn_keep_alive(), reducing
  max nesting from 7 levels to 3

etcd/register.rs

@@ -7,6 +7,7 @@ use tokio_stream::StreamExt;
 use crate::error::{AppError, AppResult};
 
 use super::EtcdRegistry;
+use super::EtcdRegistryInner;
 use super::types::ServiceInstance;
 
 impl EtcdRegistry {
@@ -63,51 +64,68 @@ impl EtcdRegistry {
 
         tokio::spawn(async move {
             loop {
-                let result = {
-                    let mut client = inner.client.lock().await;
-                    client.lease_keep_alive(lease_id).await
-                };
-
-                match result {
-                    Ok((_keeper, mut stream)) => {
-                        while let Some(resp) = stream.next().await {
-                            if let Err(e) = resp {
-                                tracing::warn!(lease_id = lease_id, error = %e, "keep-alive stream error");
-                                break;
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        tracing::warn!(lease_id = lease_id, error = %e, "keep-alive failed");
-                    }
-                }
-
+                Self::run_keep_alive_stream(&inner, lease_id).await;
                 tokio::time::sleep(std::time::Duration::from_secs(interval)).await;
-
-                let re_grant = {
-                    let mut client = inner.client.lock().await;
-                    client
-                        .lease_grant(inner.config.etcd_lease_ttl().unwrap_or(15) as i64, None)
-                        .await
-                };
-
-                if let Ok(current) = re_grant {
-                    let new_lease = current.id();
-                    inner.lease_id.store(new_lease, Ordering::SeqCst);
-
-                    let instance = ServiceInstance {
-                        addr: inner.config.rpc_self_listen_addr().unwrap_or_default(),
-                        metadata: HashMap::new(),
-                    };
-
-                    if let Ok(value) = serde_json::to_string(&instance) {
-                        let mut client = inner.client.lock().await;
-                        let opts = PutOptions::new().with_lease(new_lease);
-                        let _ = client.put(key.clone(), value, Some(opts)).await;
-                    }
-                    tracing::info!(old = lease_id, new = new_lease, "etcd lease renewed");
-                }
+                Self::renew_lease_and_reregister(&inner, lease_id, &key).await;
             }
         });
     }
 }
+
+impl EtcdRegistry {
+    async fn run_keep_alive_stream(
+        inner: &std::sync::Arc<EtcdRegistryInner>,
+        lease_id: i64,
+    ) {
+        let result = {
+            let mut client = inner.client.lock().await;
+            client.lease_keep_alive(lease_id).await
+        };
+
+        match result {
+            Ok((_keeper, mut stream)) => {
+                while let Some(resp) = stream.next().await {
+                    if let Err(e) = resp {
+                        tracing::warn!(lease_id = lease_id, error = %e, "keep-alive stream error");
+                        break;
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::warn!(lease_id = lease_id, error = %e, "keep-alive failed");
+            }
+        }
+    }
+
+    async fn renew_lease_and_reregister(
+        inner: &std::sync::Arc<EtcdRegistryInner>,
+        old_lease_id: i64,
+        key: &str,
+    ) {
+        let re_grant = {
+            let mut client = inner.client.lock().await;
+            client
+                .lease_grant(inner.config.etcd_lease_ttl().unwrap_or(15) as i64, None)
+                .await
+        };
+
+        let Ok(current) = re_grant else {
+            return;
+        };
+
+        let new_lease = current.id();
+        inner.lease_id.store(new_lease, Ordering::SeqCst);
+
+        let instance = ServiceInstance {
+            addr: inner.config.rpc_self_listen_addr().unwrap_or_default(),
+            metadata: HashMap::new(),
+        };
+
+        if let Ok(value) = serde_json::to_string(&instance) {
+            let mut client = inner.client.lock().await;
+            let opts = PutOptions::new().with_lease(new_lease);
+            let _ = client.put(key, value, Some(opts)).await;
+        }
+        tracing::info!(old = old_lease_id, new = new_lease, "etcd lease renewed");
+    }
+}