feat(tahuantinsuyu): fase 5 — overlay de tránsitos (bi-wheel natal × ahora)

Activá el toggle "Tránsitos (ahora)" en el panel (o hotkey [T] sobre
el wheel): la engine computa una segunda NatalChart al instante
SystemTime::now() con el mismo observer y dibuja un anillo externo de
planet glyphs encima del natal, más las cross-aspects entre ambos
charts (sólo mayores). Las líneas cross van del ring de cuerpos
natales al ring externo de tránsitos, con stroke más fino y opacidad
más baja para no taparle el ojo a las aspectos natal-natal.

- engine/bridge.rs: extraídas build_eternal_inputs y
  compute_natal_chart como helpers reutilizables. Nueva
  compute_with_transits(chart, offset, transit_at) que llama
  find_synastry_aspects entre natal y transit (AspectKind::MAJORS).
  Atajo compute_with_transits_at_now usa ESInstant::now(). Las capas
  extra van con module_id = "transit" y LayerKind::Outer /
  LayerKind::Aspects para que el canvas las distinga.
- engine/lib.rs: re-export de compute_with_transits_at_now con el
  mismo fallback al mock cuando feature `eternal-bridge` está off.
- canvas: nueva Radii::transits = 0.82, layout del wheel re-balanceado
  (houses_outer 0.78, houses_inner 0.66, bodies 0.58, aspects 0.50)
  para hacer lugar al anillo externo sin colisiones. paint_wheel:
  detecta layers de transit por module_id, pinta dots + glifos en el
  anillo nuevo + anillos guía sutiles. paint_cross_aspect_line con
  stroke 0.7 entre los dos radios. Glyph overlay para Outer ring con
  alpha 0.9 y font_size más chico que el natal. Hotkey [T] en
  on_key_down toggle LayerKind::Outer.
- modules: NatalModule.controls() agrega toggle show_transits con
  hotkey [T] (default false — no recomputar transits si nadie pidió).
- shell: nuevo show_transits flag. render_current despacha entre
  compute_at_offset y compute_with_transits_at_now según el flag.
  on_panel_event traduce ControlChanged show_transits a flip + redraw.
  on_canvas_event: el toggle de LayerKind::Outer dispara show_transits
  flip + render (no es un visibility toggle puro).

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

crates/modules/tahuantinsuyu/tahuantinsuyu-engine/src/bridge.rs

@@ -9,8 +9,8 @@ use std::sync::OnceLock;
 use std::time::Instant;
 
 use eternal_astrology::{
-    find_aspects, Aspect, AspectKind as EAspectKind, BirthData, BodySet, ChartConfig,
-    HouseSystem as EHouseSystem, NatalChart, OrbTable, Zodiac as EZodiac,
+    find_aspects, find_synastry_aspects, Aspect, AspectKind as EAspectKind, BirthData, BodySet,
+    ChartConfig, HouseSystem as EHouseSystem, NatalChart, OrbTable, Zodiac as EZodiac,
 };
 use eternal_sky::{Ayanamsha, Body, EphemerisSession, Instant as ESInstant, Observer, SessionConfig};
 
@@ -173,10 +173,15 @@ fn aspect_kind_id(k: EAspectKind) -> &'static str {
 // compute()
 // =====================================================================
 
-pub fn compute_at_offset(chart: &Chart, offset_minutes: i64) -> Result<RenderModel, EngineError> {
-    let t0 = Instant::now();
+/// Construye los tipos eternales (`BirthData`, `ChartConfig`) desde el
+/// `Chart` agnóstico, aplicando el offset temporal. Devuelve también el
+/// `Observer` y la `ChartConfig` para reusar en pipelines extendidas
+/// (transits, sinastría) sin re-traducir.
+fn build_eternal_inputs(
+    chart: &Chart,
+    offset_minutes: i64,
+) -> Result<(BirthData, ChartConfig, Observer), EngineError> {
     chart.validate()?;
-
     let bd = &chart.birth_data;
     let base_instant = ESInstant::from_civil_local(
         bd.year,
@@ -197,10 +202,6 @@ pub fn compute_at_offset(chart: &Chart, offset_minutes: i64) -> Result<RenderMod
     )
     .map_err(|e| EngineError::Eternal(format!("Instant::from_civil_local: {:?}", e)))?;
 
-    // Aplicar el offset (en minutos) sumando segundos al UTC y
-    // reconstruyendo el `Instant`. `UTC::add_seconds` está disponible
-    // pero opera sobre la representación interna; el `Instant` la
-    // re-envuelve vía `from_utc`.
     let instant = if offset_minutes == 0 {
         base_instant
     } else {
@@ -209,29 +210,134 @@ pub fn compute_at_offset(chart: &Chart, offset_minutes: i64) -> Result<RenderMod
     };
 
     let observer = Observer::from_degrees(bd.latitude_deg, bd.longitude_deg, bd.altitude_m);
-
     let mut birth_e = BirthData::new(instant, observer);
     if let Some(name) = &bd.subject_name {
         birth_e = birth_e.with_name(name.clone());
     }
-
     let config_e = ChartConfig {
         house_system: map_house_system(chart.config.house_system),
         zodiac: map_zodiac(chart.config.zodiac, chart.config.ayanamsha.as_deref()),
         bodies: map_body_set(&chart.config),
         include_horizon: false,
     };
+    Ok((birth_e, config_e, observer))
+}
 
+/// Computa solo la `NatalChart` (sin construir RenderModel). Útil para
+/// pipelines compuestas (transits, sinastría) que necesitan el natal
+/// crudo para correr `find_synastry_aspects`.
+fn compute_natal_chart(
+    chart: &Chart,
+    offset_minutes: i64,
+) -> Result<(NatalChart, ChartConfig, Observer), EngineError> {
+    let (birth_e, config_e, observer) = build_eternal_inputs(chart, offset_minutes)?;
     let session = session()?;
     let natal = NatalChart::compute(&birth_e, &config_e, session)
         .map_err(|e| EngineError::Eternal(format!("NatalChart::compute: {:?}", e)))?;
+    Ok((natal, config_e, observer))
+}
 
+pub fn compute_at_offset(chart: &Chart, offset_minutes: i64) -> Result<RenderModel, EngineError> {
+    let t0 = Instant::now();
+    let (natal, _, _) = compute_natal_chart(chart, offset_minutes)?;
     let aspects = find_aspects(&natal, &OrbTable::modern_western());
+    Ok(build_render_model(chart, &natal, &aspects, t0))
+}
 
-    let render = build_render_model(chart, &natal, &aspects, t0);
+/// Pipeline natal + overlay de tránsitos. Computa la carta natal
+/// (eventualmente con un `offset_minutes` aplicado) **y además** una
+/// segunda `NatalChart` con el mismo observer pero al instante
+/// `transit_at` (usualmente `Instant::now()`). Devuelve un `RenderModel`
+/// con dos capas extra:
+///
+/// - `LayerKind::Outer` con `module_id = "transit"` — glifos
+///   planetarios del cielo actual, pintados en un anillo externo.
+/// - `LayerKind::Aspects` con `module_id = "transit"` — aspectos cross
+///   natal × transit (sólo mayores). Convención: `LineSeg.from_deg` =
+///   longitud natal, `LineSeg.to_deg` = longitud transit.
+pub fn compute_with_transits(
+    chart: &Chart,
+    offset_minutes: i64,
+    transit_at: ESInstant,
+) -> Result<RenderModel, EngineError> {
+    let t0 = Instant::now();
+    let (natal, config_e, observer) = compute_natal_chart(chart, offset_minutes)?;
+    let aspects = find_aspects(&natal, &OrbTable::modern_western());
+    let mut render = build_render_model(chart, &natal, &aspects, t0);
+
+    // Carta de tránsito: mismo observer, mismo config, instante "ahora".
+    let transit_birth = BirthData::new(transit_at, observer);
+    let session = session()?;
+    let transit = NatalChart::compute(&transit_birth, &config_e, session).map_err(|e| {
+        EngineError::Eternal(format!("NatalChart::compute (transit): {:?}", e))
+    })?;
+
+    // Outer ring de glifos: planetas del cielo actual.
+    let outer_glyphs: Vec<Glyph> = transit
+        .placements
+        .iter()
+        .map(|p| Glyph {
+            deg: p.longitude.longitude_deg() as f32,
+            symbol: body_symbol(p.body).into(),
+            annotation: Some(format!("{:.1}°", p.longitude.degree_in_sign_decimal())),
+            retrograde: p.longitude_rate_rad_per_day < 0.0,
+            house: None,
+        })
+        .collect();
+    render.layers.push(Layer {
+        module_id: "transit".into(),
+        kind: LayerKind::Outer,
+        ring: 0.82,
+        z: 4,
+        geometry: Geometry::GlyphsOnly,
+        glyphs: outer_glyphs,
+    });
+
+    // Cross aspects natal × transit. find_synastry_aspects toma una lista
+    // de `AspectKind`s — usamos solo mayores para no saturar.
+    let cross = find_synastry_aspects(
+        &natal,
+        &transit,
+        &OrbTable::modern_western(),
+        EAspectKind::MAJORS,
+    );
+    let cross_lines: Vec<LineSeg> = cross
+        .iter()
+        .filter_map(|a| {
+            let natal_p = natal.placement(a.person_a_body)?;
+            let transit_p = transit.placement(a.person_b_body)?;
+            let opacity = orb_to_opacity(a.orb_abs_deg(), a.kind);
+            Some(LineSeg {
+                from_deg: natal_p.longitude.longitude_deg() as f32,
+                to_deg: transit_p.longitude.longitude_deg() as f32,
+                kind: aspect_kind_id(a.kind).into(),
+                // Apagamos un poco más los cross para distinguirlos del
+                // tejido natal-natal.
+                opacity: opacity * 0.75,
+            })
+        })
+        .collect();
+    render.layers.push(Layer {
+        module_id: "transit".into(),
+        kind: LayerKind::Aspects,
+        ring: 0.0,
+        z: 5,
+        geometry: Geometry::Lines(cross_lines),
+        glyphs: Vec::new(),
+    });
+
+    render.compute_ms = t0.elapsed().as_millis() as u64;
     Ok(render)
 }
 
+/// Atajo: tránsitos al instante actual del reloj.
+pub fn compute_with_transits_at_now(
+    chart: &Chart,
+    offset_minutes: i64,
+) -> Result<RenderModel, EngineError> {
+    compute_with_transits(chart, offset_minutes, ESInstant::now())
+}
+
 // =====================================================================
 // NatalChart → RenderModel
 // =====================================================================