feat(types): real carbon planets via per-system carbon-rich (C/O>1) flag

Make the dead tCarbon type reachable with actual physics instead of relabeling
composition noise. In a carbon-rich (C/O>1) disk, carbon/carbides condense
before silicates so terrestrial bodies are carbon-dominated (Kuchner & Seager
2005; Bond et al. 2010).

- carbon_rich_from_seed() (utils.cpp): a PURE splitmix64 hash of the per-system
  seed -> true with probability CARBON_RICH_SYSTEM_FRACTION (0.05, a conservative
  high-end estimate of the C/O>1 host fraction; the old ~25% C/O>0.8 figure was
  an overestimate). Consumes NO RandomContext draw.
- sun::carbonRich set once per system at the metallicity site (accrete.cpp), from
  the seed hash via RandomContext::getSeed() -- so it does not shift the RNG
  stream: non-carbon-rich systems are byte-identical.
- assign_composition (enviro.cpp): carbon-rich systems draw cmf=about(0.75,0.15)
  (same single draw) instead of ~0.05, crossing the existing cmf>=0.75 tCarbon
  threshold; cmf feeds the Zeng radius so carbon worlds get realistic radii.

Determinism preserved (pure hash + unchanged draw count; -T1==-T8 byte-identical
across a run spanning carbon-rich systems). Golden seeds 12345/42/7 do not hash
carbon-rich, so goldens are byte-unchanged. Verified reachable: ~5% of systems
are carbon-rich and produce "Carbon" / "Tidally Locked Carbon" worlds. 23/23 ctest.

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

Author: sirus20x6

accrete.cpp

@@ -899,6 +899,10 @@ auto accrete::dist_planetary_masses(sun &the_sun, long double inner_dust,
         GIANT_METALLICITY_MEAN +
         GIANT_METALLICITY_SIGMA * sqrt(-2.0L * log(u1)) * cos(2.0L * PI * u2);
     the_sun.setMetallicity(feh);  // expose the per-star [Fe/H] in output
+    // Carbon-rich (C/O>1) systems: a deterministic per-system flag hashed from
+    // the seed (NO RNG draw -> stream unperturbed) that makes rocky bodies
+    // carbon-dominated (-> tCarbon). See assign_composition() / const.h.
+    the_sun.setCarbonRich(carbon_rich_from_seed(random_ctx->getSeed()));
     long double p_giant = GIANT_FORMATION_NORM * stell_mass_ratio *
                           std::pow(10.0L, GIANT_FORMATION_FEH_SLOPE * feh);
     if (stell_mass_ratio > GIANT_FORMATION_MASS_TURNOVER_MSUN) {  // steep drop for A-stars

const.h

@@ -119,6 +119,18 @@ constexpr double IRON_REFRACTORY_FRACTION = 0.33;
 constexpr double ICE_MAX_FRACTION       = 0.5;
 constexpr double SOLAR_CMF              = 0.05;
 constexpr double COMPOSITION_SCATTER    = 0.15;
+/* Carbon planets: a fraction of systems form in carbon-rich (C/O>1) disks where
+ * carbon/carbides condense before silicates, so rock is carbon-dominated rather
+ * than silicate (Kuchner & Seager 2005; Bond et al. 2010). CARBON_RICH_SYSTEM_
+ * FRACTION is the per-system probability -- a deliberately conservative value at
+ * the high end of the C/O>1 host fraction (Fortney 2012); the once-claimed ~25%
+ * C/O>0.8 figure was a large overestimate (Nissen 2013; Brewer & Fischer 2016
+ * find genuine C/O>1 hosts are rare). In a carbon-rich system rocky bodies get
+ * carbon-of-rock fraction ~ CARBON_RICH_CMF_MEAN (vs solar ~0.05), crossing the
+ * existing cmf>=0.75 tCarbon threshold. The flag is a pure hash of the system
+ * seed (no RNG draw), so non-carbon-rich systems are byte-unchanged. */
+constexpr double CARBON_RICH_SYSTEM_FRACTION = 0.05;
+constexpr double CARBON_RICH_CMF_MEAN        = 0.75;
 constexpr double T_SILICATE_CONDENSE    = 1350.0; /* K; Lodders 2003 forsterite */
 
 /* --- Display-only planet-type MODIFIERS (orthogonal state, not base types) ----

enviro.cpp

@@ -2780,12 +2780,20 @@ void assign_composition(planet *the_planet, sun &the_sun, bool is_moon) {
   }
 
   if (the_planet->getCmf() == 0) {
-    long double cmf = about(SOLAR_CMF, COMPOSITION_SCATTER);  // carbon-of-rock, small/solar
+    // In a carbon-rich (C/O>1) system carbon/carbides condense before silicates,
+    // so rock is carbon-dominated -> high cmf -> the body classifies as tCarbon.
+    // Same single about() draw either way, so the RNG stream is unperturbed; only
+    // the value and clamp differ for carbon-rich systems.
+    const bool  carbon_rich = the_sun.getCarbonRich();
+    long double cmf         = carbon_rich
+                                 ? about(CARBON_RICH_CMF_MEAN, COMPOSITION_SCATTER)
+                                 : about(SOLAR_CMF, COMPOSITION_SCATTER);
     if (cmf < 0.0) {
       cmf = 0.0;
     }
-    if (cmf > 0.2) {
-      cmf = 0.2;
+    const long double cmf_cap = carbon_rich ? 1.0 : 0.2;
+    if (cmf > cmf_cap) {
+      cmf = cmf_cap;
     }
     the_planet->setCmf(cmf);
   }

structs.cpp

@@ -882,6 +882,9 @@ void sun::setAge(long double a) { age = a; }
 void sun::setMetallicity(long double m) { metallicity = m; }
 auto sun::getMetallicity() -> long double { return metallicity; }
 
+void sun::setCarbonRich(bool b) { carbonRich = b; }
+auto sun::getCarbonRich() -> bool { return carbonRich; }
+
 void sun::setEffTemp(long double e) {
   effTemp = e;
   if (specType.empty()) {

structs.h

@@ -30,9 +30,9 @@ using planet_type = enum planet_type {
            // positional type_counts[]/weighted-count table in stargen.cpp.
   tBrownDwarf,  // seb
   tIron,
-  tCarbon,  // carbon-dominated rock (Kuchner & Seager 2005). Currently only
-            // reachable in carbon-rich (C/O>1) systems, which StarGen does not
-            // yet model -- see the carbon-rich-system note in assign_type.
+  tCarbon,  // carbon-dominated rock (Kuchner & Seager 2005). Reached in carbon-
+            // rich (C/O>1) systems: sun::carbonRich (a per-system seed hash, set
+            // in accrete.cpp) boosts cmf>=0.75 in assign_composition.
   tOil      // DEPRECATED: a non-physical "oil ocean" (originally Star-Trek-
             // flavored); never assigned. Kept vestigial to preserve ordinals.
 };
@@ -64,6 +64,7 @@ class sun {
   std::string specType{""};
   long double age{0};
   long double metallicity{0};  // [Fe/H] in dex (0 = solar); drives giant formation
+  bool carbonRich{false};      // C/O>1 disk -> carbon-dominated rock (tCarbon planets)
   std::string name{""};
   bool isCircumbinary{false};
   long double secondaryMass{0};
@@ -91,6 +92,8 @@ class sun {
   auto getAge() -> long double;
   void setMetallicity(long double);
   auto getMetallicity() -> long double;
+  void setCarbonRich(bool);
+  auto getCarbonRich() -> bool;
   void setName(std::string);
   auto getName() -> std::string;
   auto getREcosphere(long double) -> long double;

utils.cpp

@@ -6,6 +6,7 @@
 #include <cctype>                   // for toupper, isspace
 #include <cmath>                    // for log, exp, pow, NAN, sqrt, fmod, abs
 #include <cstdlib>                  // for rand, abs, RAND_MAX
+#include <cstdint>                  // for std::uint64_t (carbon_rich_from_seed)
 #include <string>                   // for std::string, basic_string, operator<<
 #include "const.h"                  // for pow2, pow1_4, pow3, pow4
 #include "enviro.h"                 // for eff_temp_to_spec_type, getStarType
@@ -121,6 +122,21 @@ auto about(long double value, long double variation) -> long double {
   return (value + (value * random_number(-variation, variation)));
 }
 
+/// @brief Deterministic per-system carbon-rich (C/O>1) flag from the system seed.
+/// Pure splitmix64 hash -> uniform [0,1) compared to CARBON_RICH_SYSTEM_FRACTION.
+/// Consumes NO RandomContext draw, so it does not shift the per-system RNG stream
+/// (only carbon-rich systems' composition changes); integer-only hash keeps it
+/// byte-identical across compilers/threads.
+auto carbon_rich_from_seed(long sys_seed) -> bool {
+  std::uint64_t z = static_cast<std::uint64_t>(sys_seed) + 0x9E3779B97F4A7C15ULL;
+  z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+  z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+  z = z ^ (z >> 31);
+  // Top 53 bits -> double in [0,1).
+  const double u = static_cast<double>(z >> 11) * (1.0 / 9007199254740992.0);
+  return u < CARBON_RICH_SYSTEM_FRACTION;
+}
+
 /// @brief 
 /// @param ecc_coef 
 /// @return 

utils.h

@@ -42,6 +42,10 @@ auto escapeCelestiaId(const std::string&) -> std::string;
 auto random_number(long double, long double) -> long double;
 auto random_number_int(int min, int max) -> int;
 auto about(long double, long double) -> long double;
+// Deterministic per-system "carbon-rich" (C/O>1) flag from the system seed via a
+// splitmix64 hash. PURE -- consumes NO RandomContext draw, so it does not shift
+// the per-system RNG stream. True with probability CARBON_RICH_SYSTEM_FRACTION.
+auto carbon_rich_from_seed(long sys_seed) -> bool;
 auto random_eccentricity(long double) -> long double;
 auto gaussian(long double) -> long double;
 auto poisson(long double) -> long;