feature: set impl in redis and memory with inner pass-through

src/handle_resolver/memory.rs

···
 
         result
     }
+
+    async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
+        // Normalize the handle to lowercase
+        let handle = handle.to_lowercase();
+        
+        // Update the in-memory cache
+        {
+            let mut cache = self.cache.write().await;
+            let timestamp = Self::current_timestamp();
+            cache.insert(
+                handle.clone(),
+                ResolveHandleResult::Found(timestamp, did.to_string()),
+            );
+            self.metrics.incr("resolver.memory.set").await;
+            tracing::debug!("Set handle {} -> DID {} in memory cache", handle, did);
+            
+            // Track cache size
+            let cache_size = cache.len() as u64;
+            self.metrics
+                .gauge("resolver.memory.cache_entries", cache_size)
+                .await;
+        }
+        
+        // Chain to inner resolver
+        self.inner.set(&handle, did).await
+    }
 }
 
 /// Create a new in-memory caching handle resolver.

src/handle_resolver/proactive_refresh.rs

···
 
         Ok((did, resolve_time))
     }
+
+    async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
+        // Simply chain to inner resolver - no proactive refresh needed for manual sets
+        self.inner.set(handle, did).await
+    }
 }
 
 /// Create a ProactiveRefreshResolver with custom threshold using trait objects

src/handle_resolver/rate_limited.rs

···
         // With permit acquired, forward to inner resolver
         self.inner.resolve(s).await
     }
+
+    async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
+        // Set operations don't need rate limiting since they're typically administrative
+        // and don't involve network calls to external services
+        self.inner.set(handle, did).await
+    }
 }
 
 /// Create a rate-limited handle resolver.

src/handle_resolver/sqlite.rs

···
 
         result
     }
+
+    async fn set(&self, handle: &str, did: &str) -> Result<(), HandleResolverError> {
+        // Normalize the handle to lowercase
+        let handle = handle.to_lowercase();
+        
+        // Update the SQLite cache
+        if let Ok(mut conn) = self.pool.acquire().await {
+            // Create a resolution result for the successful mapping
+            let resolution_result = match HandleResolutionResult::success(did) {
+                Ok(res) => res,
+                Err(e) => {
+                    tracing::warn!("Failed to create resolution result for set operation: {}", e);
+                    self.metrics.incr("resolver.sqlite.set_result_create_error").await;
+                    // Still chain to inner resolver even if we can't cache
+                    return self.inner.set(&handle, did).await;
+                }
+            };
+
+            // Serialize to bytes
+            match resolution_result.to_bytes() {
+                Ok(bytes) => {
+                    // Insert or update the cache entry
+                    let timestamp = std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap_or_default()
+                        .as_secs() as i64;
+                    
+                    let expires_at = timestamp + self.ttl_seconds as i64;
+                    
+                    match sqlx::query(
+                        "INSERT OR REPLACE INTO handle_resolution_cache (handle, resolved_value, created_at, expires_at) VALUES (?, ?, ?, ?)"
+                    )
+                    .bind(&handle)
+                    .bind(&bytes)
+                    .bind(timestamp)
+                    .bind(expires_at)
+                    .execute(&mut *conn)
+                    .await
+                    {
+                        Ok(_) => {
+                            tracing::debug!("Set handle {} -> DID {} in SQLite cache", handle, did);
+                            self.metrics.incr("resolver.sqlite.set_success").await;
+                        }
+                        Err(e) => {
+                            tracing::warn!("Failed to set handle->DID mapping in SQLite: {}", e);
+                            self.metrics.incr("resolver.sqlite.set_cache_error").await;
+                            // Still chain to inner resolver even if cache update fails
+                        }
+                    }
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to serialize resolution result for set operation: {}", e);
+                    self.metrics.incr("resolver.sqlite.set_serialize_error").await;
+                    // Still chain to inner resolver even if serialization fails
+                }
+            }
+        } else {
+            tracing::warn!("Failed to get SQLite connection for set operation");
+            self.metrics.incr("resolver.sqlite.set_connection_error").await;
+        }
+        
+        // Chain to inner resolver
+        self.inner.set(&handle, did).await
+    }
 }
 
 /// Create a new SQLite-backed handle resolver with default 90-day TTL.