feat: ultraclaw droid batch — ROADMAP #41 test isolation + #50 PowerShell permissions

Merged late-arriving droid output from 10 parallel ultraclaw sessions.

ROADMAP #41 — Test isolation for plugin regression checks:
- Add test_isolation.rs module with env_lock() for test environment isolation
- Redirect HOME/XDG_CONFIG_HOME/XDG_DATA_HOME to unique temp dirs per test
- Prevent host ~/.claude/plugins/ from bleeding into test runs
- Auto-cleanup temp directories on drop via RAII pattern
- Tests: 39 plugin tests passing

ROADMAP #50 — PowerShell workspace-aware permissions:
- Add is_safe_powershell_command() for command-level permission analysis
- Add is_path_within_workspace() for workspace boundary validation
- Classify read-only vs write-requiring bash commands (60+ commands)
- Dynamic permission requirements based on command type and target path
- Tests: permission enforcer and workspace boundary tests passing

Additional improvements:
- runtime/src/permission_enforcer.rs: Dynamic permission enforcement layer
  - check_with_required_mode() for dynamically-determined permissions
  - 60+ read-only command patterns (cat, find, grep, cargo, git, jq, yq, etc.)
  - Workspace-path detection for safe commands
- compat-harness/src/lib.rs: Compat harness updates for permission testing
- rusty-claude-cli/src/main.rs: CLI integration for permission modes
- plugins/src/lib.rs: Updated imports for test isolation module

Total: +410 lines across 5 files
Workspace tests: 448+ passed
Droid source: ultraclaw-04-test-isolation, ultraclaw-08-powershell-permissions

Ultraclaw total: 4 ROADMAP items committed (38, 40, 41, 50)

rust/crates/plugins/src/test_isolation.rs

@@ -0,0 +1,72 @@
+// Test isolation utilities for plugin tests
+// ROADMAP #41: Stop ambient plugin state from skewing CLI regression checks
+
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
+use std::env;
+use std::path::PathBuf;
+
+static TEST_COUNTER: AtomicU64 = AtomicU64::new(0);
+static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+/// Lock for test environment isolation
+pub struct EnvLock {
+    _guard: std::sync::MutexGuard<'static, ()>,
+    temp_home: PathBuf,
+}
+
+impl EnvLock {
+    /// Acquire environment lock for test isolation
+    pub fn lock() -> Self {
+        let guard = ENV_LOCK.lock().unwrap();
+        let count = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let temp_home = std::env::temp_dir().join(format!("plugin-test-{}", count));
+        
+        // Set up isolated environment
+        std::fs::create_dir_all(&temp_home).ok();
+        std::fs::create_dir_all(temp_home.join(".claude/plugins/installed")).ok();
+        std::fs::create_dir_all(temp_home.join(".config")).ok();
+        
+        // Redirect HOME and XDG_CONFIG_HOME to temp directory
+        env::set_var("HOME", &temp_home);
+        env::set_var("XDG_CONFIG_HOME", temp_home.join(".config"));
+        env::set_var("XDG_DATA_HOME", temp_home.join(".local/share"));
+        
+        EnvLock {
+            _guard: guard,
+            temp_home,
+        }
+    }
+    
+    /// Get the temporary home directory for this test
+    pub fn temp_home(&self) -> &PathBuf {
+        &self.temp_home
+    }
+}
+
+impl Drop for EnvLock {
+    fn drop(&mut self) {
+        // Cleanup temp directory
+        std::fs::remove_dir_all(&self.temp_home).ok();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_env_lock_creates_isolated_home() {
+        let lock = EnvLock::lock();
+        let home = env::var("HOME").unwrap();
+        assert!(home.contains("plugin-test-"));
+        assert_eq!(home, lock.temp_home().to_str().unwrap());
+    }
+    
+    #[test]
+    fn test_env_lock_creates_plugin_directories() {
+        let lock = EnvLock::lock();
+        let plugins_dir = lock.temp_home().join(".claude/plugins/installed");
+        assert!(plugins_dir.exists());
+    }
+}