refactor: extract voice loading logic to domain layer

- Add abogen/domain/voice_loader.py with:
  - VoiceCache class: unified cache for loaded voices
  - resolve_voice(): load voice with optional caching
  - load_voice_cached(): compatibility wrapper for PyQt

- Update abogen/pyqt/conversion.py:
  - Replace load_voice_cached method body with call to domain function
  - Maintain backward compatibility with existing interface

- Add tests/test_voice_loader.py with unit tests for VoiceCache and voice loading

tests/test_voice_loader.py

@@ -0,0 +1,137 @@
+"""Tests for abogen.domain.voice_loader module."""
+
+import pytest
+
+from abogen.domain.voice_loader import (
+    VoiceCache,
+    resolve_voice,
+    load_voice_cached,
+)
+
+
+class TestVoiceCache:
+    """Tests for VoiceCache class."""
+
+    def test_get_set(self):
+        """Test basic get/set operations."""
+        cache = VoiceCache()
+        cache.set("test_voice", "loaded_voice")
+        assert cache.get("test_voice") == "loaded_voice"
+
+    def test_get_missing(self):
+        """Test get returns None for missing voice."""
+        cache = VoiceCache()
+        assert cache.get("missing_voice") is None
+
+    def test_contains(self):
+        """Test contains method."""
+        cache = VoiceCache()
+        cache.set("test_voice", "loaded_voice")
+        assert cache.contains("test_voice")
+        assert not cache.contains("missing_voice")
+
+    def test_in_operator(self):
+        """Test __contains__ (in operator)."""
+        cache = VoiceCache()
+        cache.set("test_voice", "loaded_voice")
+        assert "test_voice" in cache
+        assert "missing_voice" not in cache
+
+    def test_clear(self):
+        """Test clear method."""
+        cache = VoiceCache()
+        cache.set("voice1", "loaded1")
+        cache.set("voice2", "loaded2")
+        cache.clear()
+        assert not cache.contains("voice1")
+        assert not cache.contains("voice2")
+
+
+class TestResolveVoice:
+    """Tests for resolve_voice function."""
+
+    def test_simple_voice_name(self):
+        """Test that simple voice names are returned as-is."""
+        result = resolve_voice(
+            voice_spec="test_voice",
+            pipeline=None,
+            use_gpu=False,
+        )
+        assert result == "test_voice"
+
+    def test_formula_voice_without_pipeline(self):
+        """Test formula voice returns spec when no pipeline."""
+        result = resolve_voice(
+            voice_spec="model*0.5+0.3*other",
+            pipeline=None,
+            use_gpu=False,
+        )
+        assert result == "model*0.5+0.3*other"
+
+    def test_caching(self):
+        """Test that voices are cached."""
+        cache = VoiceCache()
+        
+        # First call should load (we'll mock with simple name)
+        result1 = resolve_voice(
+            voice_spec="test_voice",
+            pipeline=None,
+            use_gpu=False,
+            cache=cache,
+        )
+        assert result1 == "test_voice"
+        assert cache.contains("test_voice")
+        
+        # Second call should use cache
+        result2 = resolve_voice(
+            voice_spec="test_voice",
+            pipeline=None,
+            use_gpu=False,
+            cache=cache,
+        )
+        assert result2 == "test_voice"
+
+
+class TestLoadVoiceCached:
+    """Tests for load_voice_cached function."""
+
+    def test_simple_voice_name(self):
+        """Test that simple voice names are returned as-is."""
+        result = load_voice_cached(
+            voice_name="test_voice",
+            pipeline=None,
+            use_gpu=False,
+        )
+        assert result == "test_voice"
+
+    def test_dict_cache(self):
+        """Test caching with dict."""
+        cache = {}
+        
+        result1 = load_voice_cached(
+            voice_name="test_voice",
+            pipeline=None,
+            use_gpu=False,
+            cache=cache,
+        )
+        assert result1 == "test_voice"
+        assert "test_voice" in cache
+        
+        result2 = load_voice_cached(
+            voice_name="test_voice",
+            pipeline=None,
+            use_gpu=False,
+            cache=cache,
+        )
+        assert result2 == "test_voice"
+        assert cache["test_voice"] == "test_voice"
+
+    def test_no_cache(self):
+        """Test without cache parameter."""
+        result = load_voice_cached(
+            voice_name="test_voice",
+            pipeline=None,
+            use_gpu=False,
+            cache=None,
+        )
+        assert result == "test_voice"