feat(tahuantinsuyu): fase 13 — Solar Return como sexto overlay

Sexto módulo siguiendo el patrón establecido. Cambio estructural:
3-way mutual exclusion para los módulos que comparten el outer ring
(transit + synastry + solar_return). Constante OUTER_RING_MODULES
abstrae el grupo para que fase 14+ pueda sumar lunar return / planet
returns sin tocar la lógica del shell.

- engine: PipelineRequest::SolarReturn { target_age_years } +
  build_solar_return_overlay. Llama eternal_astrology::next_return
  (Sun back to natal Sun, ventana ±1.5 años) desde un instante
  ~30 días antes del cumpleaños target. Computa la carta natal
  completa al return_instant (mismo observer + config natales —
  convención clásica) y la apila como Outer + Aspects cross natal ×
  return. z=12/13. Import: `next_return` añadido a la lista de
  re-exports del bridge.
- modules: solar_return::SolarReturnModule (id "solar_return", toggle
  + slider target_age_years 0..120 step 1.0). Registry pasa a 6
  módulos para Natal.
- shell: OUTER_RING_MODULES const con los tres ids; mutual exclusion
  generalizada de pair-wise a N-way (for-loop sobre el slice). Init
  de age en apply_selection ahora incluye solar_return. build_requests
  agrega la rama. Misma estructura que progression/solar_arc en la
  rama de age handling.
- canvas: aspect_endpoints("solar_return") = (bodies, transits). Tres
  loops del outer ring (paint dots, paint glyphs, anillos guía) ahora
  aceptan los tres module_ids.

Probarlo: en el panel, slider "Edad del retorno" en valor entero (ej.
36) + toggle "Activar" = ves la carta del año cuando volviste a tu
Sol natal a los 36, con todos sus planetas en el outer ring y cross
aspects con tu natal. Cambiando el slider podés explorar año por año.

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, find_synastry_aspects, secondary_progression, solar_arc_true, Aspect,
-    AspectKind as EAspectKind, BirthData, BodySet, ChartConfig, HouseSystem as EHouseSystem,
+    find_aspects, find_synastry_aspects, next_return, secondary_progression, solar_arc_true,
+    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};
@@ -264,6 +264,15 @@ pub fn compose(
             crate::PipelineRequest::Synastry { partner_chart } => {
                 build_synastry_overlay(&natal, partner_chart, &mut render)?;
             }
+            crate::PipelineRequest::SolarReturn { target_age_years } => {
+                build_solar_return_overlay(
+                    &natal,
+                    &config_e,
+                    observer,
+                    *target_age_years,
+                    &mut render,
+                )?;
+            }
         }
     }
 
@@ -531,6 +540,100 @@ fn build_synastry_overlay(
     Ok(())
 }
 
+/// Helper: agrega al `RenderModel` las capas del overlay de Solar
+/// Return — la carta natal completa computada al instante en que el
+/// Sol vuelve a su posición natal en el año pedido. Esa nueva carta
+/// va en el anillo externo (compartido con Transit/Synastry —
+/// mutuamente excluyentes a nivel de Shell). Cross aspects natal ×
+/// return.
+fn build_solar_return_overlay(
+    natal: &NatalChart,
+    config_e: &ChartConfig,
+    observer: Observer,
+    target_age_years: f64,
+    render: &mut RenderModel,
+) -> Result<(), EngineError> {
+    let session = session()?;
+    let natal_sun = natal.placement(Body::Sun).ok_or_else(|| {
+        EngineError::Eternal("natal chart sin Sol — Solar Return imposible".into())
+    })?;
+    let natal_sun_lon = natal_sun.longitude.longitude_rad();
+
+    // Buscar el próximo retorno desde un punto razonable antes del
+    // cumpleaños del año target. Restamos 30 días para garantizar que
+    // el retorno (que cae ~en la fecha de nacimiento) quede DENTRO de
+    // la ventana de búsqueda.
+    const TROPICAL_YEAR_SECS: f64 = 365.242190 * 86400.0;
+    let after_seconds = (target_age_years * 365.242190 - 30.0) * 86400.0;
+    let after_utc = natal
+        .birth
+        .instant
+        .utc()
+        .add_seconds(after_seconds.max(-TROPICAL_YEAR_SECS * 2.0));
+    let after = ESInstant::from_utc(after_utc);
+
+    let return_instant = next_return(session, Body::Sun, natal_sun_lon, after, None)
+        .map_err(|e| EngineError::Eternal(format!("next_return Sun: {:?}", e)))?;
+
+    // La carta del retorno se computa al return_instant con el mismo
+    // observer y config natales (convención clásica: solar return
+    // tropical en la ciudad de nacimiento).
+    let return_birth = BirthData::new(return_instant, observer);
+    let return_chart = NatalChart::compute(&return_birth, config_e, session).map_err(|e| {
+        EngineError::Eternal(format!("NatalChart::compute (solar return): {:?}", e))
+    })?;
+
+    let glyphs: Vec<Glyph> = return_chart
+        .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: Some(p.house_number),
+        })
+        .collect();
+    render.layers.push(Layer {
+        module_id: "solar_return".into(),
+        kind: LayerKind::Outer,
+        ring: 0.82,
+        z: 12,
+        geometry: Geometry::GlyphsOnly,
+        glyphs,
+    });
+
+    let cross = find_synastry_aspects(
+        natal,
+        &return_chart,
+        &OrbTable::modern_western(),
+        EAspectKind::MAJORS,
+    );
+    let cross_lines: Vec<LineSeg> = cross
+        .iter()
+        .filter_map(|a| {
+            let n_p = natal.placement(a.person_a_body)?;
+            let r_p = return_chart.placement(a.person_b_body)?;
+            let opacity = orb_to_opacity(a.orb_abs_deg(), a.kind);
+            Some(LineSeg {
+                from_deg: n_p.longitude.longitude_deg() as f32,
+                to_deg: r_p.longitude.longitude_deg() as f32,
+                kind: aspect_kind_id(a.kind).into(),
+                opacity: opacity * 0.8,
+            })
+        })
+        .collect();
+    render.layers.push(Layer {
+        module_id: "solar_return".into(),
+        kind: LayerKind::Aspects,
+        ring: 0.0,
+        z: 13,
+        geometry: Geometry::Lines(cross_lines),
+        glyphs: Vec::new(),
+    });
+    Ok(())
+}
+
 // =====================================================================
 // NatalChart → RenderModel
 // =====================================================================