feat(gateway): implement remote service forwarding for distributed git operations

- Add remote client functions for archive, blame, and branch services
- Implement fallback logic to forward requests to remote storage nodes
- Add logging for forwarding operations with route details
- Update Cargo.lock with new dependencies including ractor cluster libraries
- Extend .gitignore with IDE and build system files
- Remove outdated comments from bare repository implementation

server/tag.rs

@@ -1,7 +1,27 @@
 use crate::pb::*;
+use crate::pb::tag_service_client::TagServiceClient;
 
 use super::{GitksService, into_status};
 
+async fn remote_tag_client(
+    svc: &GitksService,
+    header: Option<&RepositoryHeader>,
+) -> Result<Option<TagServiceClient<tonic::transport::Channel>>, tonic::Status> {
+    let header = match header {
+        Some(h) => h,
+        None => return Ok(None),
+    };
+    let Some(route) = svc.route_repository(header).await? else {
+        return Ok(None);
+    };
+    tracing::info!(storage_name = %route.storage_name, relative_path = %route.relative_path, actor_name = %route.actor_name, grpc_addr = %route.grpc_addr, "forwarding tag rpc");
+    let endpoint = super::remote_endpoint(&route.grpc_addr).await?;
+    let client = TagServiceClient::connect(endpoint)
+        .await
+        .map_err(|e| tonic::Status::unavailable(e.to_string()))?;
+    Ok(Some(client))
+}
+
 #[tonic::async_trait]
 impl tag_service_server::TagService for GitksService {
     async fn list_tags(
@@ -12,7 +32,16 @@ impl tag_service_server::TagService for GitksService {
         let repo = self.repo_label(inner.repository.as_ref());
         let span = tracing::info_span!("tag.list_tags", %repo);
         let _enter = span.enter();
-        let gb = self.resolve(inner.repository.as_ref())?;
+        let gb = match self.resolve(inner.repository.as_ref()) {
+            Ok(gb) => gb,
+            Err(err) if err.code() == tonic::Code::NotFound => {
+                if let Some(mut client) = remote_tag_client(self, inner.repository.as_ref()).await? {
+                    return client.list_tags(inner).await;
+                }
+                return Err(err);
+            }
+            Err(err) => return Err(err),
+        };
         let resp = gb.list_tags(inner).map_err(into_status)?;
         tracing::info!(%repo, count = resp.tags.len(), "list_tags done");
         Ok(tonic::Response::new(resp))
@@ -27,7 +56,16 @@ impl tag_service_server::TagService for GitksService {
         let name = inner.name.clone();
         let span = tracing::info_span!("tag.get_tag", %repo, %name);
         let _enter = span.enter();
-        let gb = self.resolve(inner.repository.as_ref())?;
+        let gb = match self.resolve(inner.repository.as_ref()) {
+            Ok(gb) => gb,
+            Err(err) if err.code() == tonic::Code::NotFound => {
+                if let Some(mut client) = remote_tag_client(self, inner.repository.as_ref()).await? {
+                    return client.get_tag(inner).await;
+                }
+                return Err(err);
+            }
+            Err(err) => return Err(err),
+        };
         let resp = gb.get_tag(inner).map_err(into_status)?;
         Ok(tonic::Response::new(resp))
     }
@@ -41,7 +79,16 @@ impl tag_service_server::TagService for GitksService {
         let name = inner.name.clone();
         let span = tracing::info_span!("tag.create_tag", %repo, %name);
         let _enter = span.enter();
-        let gb = self.resolve(inner.repository.as_ref())?;
+        let gb = match self.resolve(inner.repository.as_ref()) {
+            Ok(gb) => gb,
+            Err(err) if err.code() == tonic::Code::NotFound => {
+                if let Some(mut client) = remote_tag_client(self, inner.repository.as_ref()).await? {
+                    return client.create_tag(inner).await;
+                }
+                return Err(err);
+            }
+            Err(err) => return Err(err),
+        };
         let resp = gb.create_tag(inner).map_err(into_status)?;
         tracing::info!(%repo, %name, "tag created");
         Ok(tonic::Response::new(resp))
@@ -56,7 +103,16 @@ impl tag_service_server::TagService for GitksService {
         let name = inner.name.clone();
         let span = tracing::info_span!("tag.delete_tag", %repo, %name);
         let _enter = span.enter();
-        let gb = self.resolve(inner.repository.as_ref())?;
+        let gb = match self.resolve(inner.repository.as_ref()) {
+            Ok(gb) => gb,
+            Err(err) if err.code() == tonic::Code::NotFound => {
+                if let Some(mut client) = remote_tag_client(self, inner.repository.as_ref()).await? {
+                    return client.delete_tag(inner).await;
+                }
+                return Err(err);
+            }
+            Err(err) => return Err(err),
+        };
         gb.delete_tag(inner).map_err(into_status)?;
         tracing::info!(%repo, %name, "tag deleted");
         Ok(tonic::Response::new(()))
@@ -71,7 +127,16 @@ impl tag_service_server::TagService for GitksService {
         let name = inner.name.clone();
         let span = tracing::info_span!("tag.verify_tag", %repo, %name);
         let _enter = span.enter();
-        let gb = self.resolve(inner.repository.as_ref())?;
+        let gb = match self.resolve(inner.repository.as_ref()) {
+            Ok(gb) => gb,
+            Err(err) if err.code() == tonic::Code::NotFound => {
+                if let Some(mut client) = remote_tag_client(self, inner.repository.as_ref()).await? {
+                    return client.verify_tag(inner).await;
+                }
+                return Err(err);
+            }
+            Err(err) => return Err(err),
+        };
         let resp = gb.verify_tag(inner).map_err(into_status)?;
         tracing::info!(%repo, %name, verified = resp.verified, "tag verified");
         Ok(tonic::Response::new(resp))