feat(tahuantinsuyu): fase 10 — Sinastría como overlay (bi-wheel con carta hermana)

Quinto módulo overlay. Cuando hay otra carta hermana del mismo
contacto, la sinastría pone las posiciones del partner en el outer
ring + dibuja cross aspects entre las dos personas. Mismo molde que
los overlays anteriores; única novedad: el PipelineRequest transporta
una `Chart` completa porque el partner no es derivable de la natal.

- engine: PipelineRequest::Synastry { partner_chart: Box<Chart> }.
  build_synastry_overlay(natal, partner_chart, render) llama
  compute_natal_chart sobre el partner y find_synastry_aspects entre
  los dos NatalCharts (sólo majors). Layers con module_id="synastry"
  y z=10/11. Reusa la helper compute_natal_chart de fase 5.
- modules: synastry::SynastryModule (id "synastry", toggle "Activar"
  sin hotkey por ahora). Registry agrega el quinto built-in. Test
  pasó a 5 módulos aplicables a ChartKind::Natal.
- shell: build_requests detecta synastry.enabled y llama
  find_synastry_partner — busca la primera carta hermana del contacto
  actual (mismo contact_id, distinto chart_id). Si no hay hermana,
  skip silencioso. Mutual exclusion: al prender transit o synastry
  se apaga el otro automáticamente (comparten outer ring) — sincroniza
  el toggle del panel + el layer_visibility del canvas.
- canvas: Radii::aspect_endpoints("synastry") devuelve (bodies,
  transits) — same slot que transit. Loops del outer ring aceptan
  module_id "transit" OR "synastry" (paint_wheel + glyph overlay).
  Sin radii nuevo — visualmente comparten el ring 0.82 con transit.

Para probarlo: creá dos cartas en el mismo contacto (ej. el sujeto +
su pareja). Abrí la primera y activá "Sinastría" en el panel. Verás
los planetas del partner en el outer ring + líneas que cruzan al
centro mostrando los aspectos entre las dos personas. Si tenés
transit prendido cuando lo activás, se apaga; al revés también.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/apps/tahuantinsuyu/src/shell.rs

@@ -206,9 +206,25 @@ impl Shell {
                 target_age_years: age,
             });
         }
+        if module_enabled(&self.module_configs, "synastry") {
+            if let Some(partner) = self.find_synastry_partner() {
+                requests.push(PipelineRequest::Synastry {
+                    partner_chart: Box::new(partner),
+                });
+            }
+        }
         requests
     }
 
+    /// Encuentra una carta hermana del contacto actual (cualquier otra
+    /// carta con el mismo `contact_id` ≠ self). `None` si no hay
+    /// hermana — el shell salta el request silenciosamente.
+    fn find_synastry_partner(&self) -> Option<Chart> {
+        let current = self.current_chart.as_ref()?;
+        let siblings = self.store.list_charts(current.contact_id).ok()?;
+        siblings.into_iter().find(|c| c.id != current.id)
+    }
+
     /// Lee `target_age_years` del módulo o cae a la edad actual del
     /// sujeto (calculada desde la fecha de nacimiento y el reloj).
     fn module_age_or_current(&self, module_id: &str) -> f64 {
@@ -321,9 +337,29 @@ impl Shell {
                     if let serde_json::Value::Object(map) = entry {
                         map.insert(key.clone(), value.clone());
                     }
+                    // Transit y Synastry comparten el outer ring del
+                    // canvas — son mutuamente excluyentes. Al prender
+                    // uno, apagamos el otro y sincronizamos el panel.
+                    if key == "enabled" && bool_val {
+                        let conflicting = match module_id.as_str() {
+                            "transit" => Some("synastry"),
+                            "synastry" => Some("transit"),
+                            _ => None,
+                        };
+                        if let Some(other) = conflicting {
+                            if module_enabled(&self.module_configs, other) {
+                                set_module_enabled(&mut self.module_configs, other, false);
+                                let other_str = other.to_string();
+                                self.panel.update(cx, |p, cx| {
+                                    p.set_toggle(&other_str, "enabled", false, cx)
+                                });
+                            }
+                        }
+                    }
                     // Sincronizar visualmente el toggle [T] del canvas
-                    // cuando el cambio fue al "enabled" del transit.
-                    if module_id == "transit" && key == "enabled" {
+                    // cuando el cambio afecta el outer ring (transit o
+                    // synastry — ambos lo usan).
+                    if (module_id == "transit" || module_id == "synastry") && key == "enabled" {
                         self.canvas.update(cx, |c, cx| {
                             c.set_layer_visible(LayerKind::Outer, bool_val, cx)
                         });