feat(phase-2.5): mutate_prompt_llm operator + weighted dispatcher + GA wiring

Implementazione completa Phase 2.5 (LLM prompt mutator) seguendo il piano in
docs/superpowers/plans/2026-05-11-mutate-prompt-llm-phase-2-5.md.

Nuovo modulo src/multi_swarm/genome/mutation_prompt_llm.py:
- 6 mutation instructions (tighten_threshold, swap_comparator, add_condition,
  remove_condition, change_timeframe, add_temporal_gate)
- mutate_prompt_llm(g, llm, rng, mutator_tier=ModelTier.B): clona genome con
  tier B per la call mutator, costruisce system+user prompt con istruzione
  scelta random, estrae prompt da tag <prompt>...</prompt>, valida
- is_valid_prompt(): 3 check (lunghezza >= 50, keyword tecnica, diff > 5%
  Levenshtein-like via difflib.SequenceMatcher)
- Fallback random_mutate su qualsiasi validation fail O LLM exception

Esteso src/multi_swarm/genome/mutation.py con weighted_random_mutate dispatcher:
con probabilità prompt_mutation_weight invoca mutate_prompt_llm, altrimenti
random_mutate. Backward compat: llm=None oppure weight=0 → solo scalare.

Integrazione GA loop + RunConfig:
- GAConfig.prompt_mutation_weight: float = 0.0 (default off)
- next_generation(llm=...) propagato all'invocazione mutator
- RunConfig.prompt_mutation_weight con stesso default
- run_phase1: passa llm a next_generation solo se weight > 0
- scripts/run_phase1.py: flag CLI --prompt-mutation-weight

Tests (+18, 175 totale):
- tests/unit/test_mutation_prompt_llm.py (12): extract_prompt, is_valid_prompt
  3 check, operator success + fallback su 3 modi (invalid/identical/exception),
  tier B per LLM call, istruzione scelta dal pool
- tests/unit/test_mutation_dispatcher.py (4): weight 0/1/None + distribuzione
  30/70 su 1000 estrazioni con tolleranza ±5%
- tests/integration/test_ga_loop_with_prompt_mutator.py (2): loop con
  weight=1.0 produce prompt evoluti; backward compat weight=0 invariato

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/integration/test_ga_loop_with_prompt_mutator.py

@@ -0,0 +1,104 @@
+"""Integration test Phase 2.5: GA loop con LLM mutator attivo.
+
+Verifica che ``next_generation`` con ``prompt_mutation_weight > 0`` e ``llm``
+fornito produca figli con system_prompt mutato dall'LLM (e non solo scalari).
+"""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+from multi_swarm.ga.loop import GAConfig, next_generation
+from multi_swarm.genome.hypothesis import HypothesisAgentGenome, ModelTier
+
+_PROMPT_TEMPLATES = (
+    "Strategia mean-reversion 1h. Entry long RSI(14) < 30 e close > SMA(50). Stop 2%.",
+    "Strategia momentum breakout. Entry long close > SMA(20) e ATR(14) crescente.",
+    "Strategia trend-following 4h. Long SMA(20) > SMA(50). Short opposito.",
+)
+
+
+def _make_pop(n: int) -> list[HypothesisAgentGenome]:
+    return [
+        HypothesisAgentGenome(
+            system_prompt=_PROMPT_TEMPLATES[i % len(_PROMPT_TEMPLATES)],
+            feature_access=["close", "high"],
+            temperature=0.9 + 0.01 * i,
+            top_p=0.95,
+            model_tier=ModelTier.C,
+            lookback_window=200,
+            cognitive_style="physicist",
+        )
+        for i in range(n)
+    ]
+
+
+@dataclass
+class _Result:
+    text: str
+
+
+class _MutatorLLM:
+    """Mock che produce un prompt diverso (e valido) a ogni call."""
+
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def complete(self, genome, system, user, max_tokens: int = 2000) -> _Result:
+        self.calls += 1
+        # Prompt sempre diverso per garantire validation pass.
+        return _Result(
+            text=(
+                f"<prompt>Strategia evolved #{self.calls}. Entry long quando "
+                f"RSI(14) < {25 + self.calls % 10} e close > SMA({40 + self.calls}). "
+                f"Exit short quando momentum decade. Trade rule {self.calls}.</prompt>"
+            )
+        )
+
+
+def test_loop_with_prompt_mutator_produces_prompt_diversity() -> None:
+    """Con weight 1.0 + crossover 0 (solo mutation), tutti i child non-elite
+    devono avere system_prompt diverso dai parent (LLM-mutated)."""
+    rng = random.Random(0)
+    pop = _make_pop(5)
+    fitnesses = {g.id: 0.0 for g in pop}
+    cfg = GAConfig(
+        population_size=5,
+        elite_k=1,
+        tournament_k=2,
+        p_crossover=0.0,  # nessun crossover → tutta la non-elite è mutation
+        prompt_mutation_weight=1.0,
+    )
+    llm = _MutatorLLM()
+
+    new_pop = next_generation(pop, fitnesses, cfg, rng, llm=llm)
+
+    assert len(new_pop) == 5
+    # 4 non-elite figli, tutti con prompt evoluti.
+    parent_prompts = {g.system_prompt for g in pop}
+    evolved = [g for g in new_pop[1:] if g.system_prompt not in parent_prompts]
+    assert len(evolved) >= 3, f"Solo {len(evolved)} figli con prompt mutato"
+    assert llm.calls >= 4
+
+
+def test_loop_backward_compat_no_llm_no_prompt_mutation() -> None:
+    """Default weight=0.0 + llm=None → comportamento identico a Phase 2."""
+    rng = random.Random(0)
+    pop = _make_pop(5)
+    fitnesses = {g.id: float(i) for i, g in enumerate(pop)}
+    cfg = GAConfig(
+        population_size=5,
+        elite_k=1,
+        tournament_k=2,
+        p_crossover=0.0,
+        prompt_mutation_weight=0.0,
+    )
+
+    new_pop = next_generation(pop, fitnesses, cfg, rng, llm=None)
+
+    assert len(new_pop) == 5
+    # Nessun child con prompt diverso dai parent: solo mutazioni scalari.
+    parent_prompts = {g.system_prompt for g in pop}
+    for child in new_pop:
+        assert child.system_prompt in parent_prompts