[patch] Fix storage conversion regressions from exact factors

[matt-edmondson]

Integer storage converts again, and exact factors stay exact

Versions 5.2.0 through 5.2.3 break every quantity stored as an integer. Since #226,
Length<int>.FromKilometer(1) throws TypeInitializationException instead of returning 1000, and so
does every other factory and every In(unit) for int and long. This PR restores the 5.1 behavior
exactly: each factor succeeds or throws OverflowException on its own, at the call that uses it.

It also fixes the other review findings on #226:

• StorageMath.Sqrt returned a wrong root without complaint for values a double cannot hold. A
  BigInteger of 2^2048 gave about 2^1792. It now gives 2^1024, or throws if Newton's method does not
  settle.
• Every literal built on π was wrong past its 97th to 104th significant digit, in conversions.json
  and domains.json. They are recomputed from π and correctly rounded to 150 significant digits.
• SEM009 accepted values that do not compile (100000000000000000000, 1e400).
• A numeric type whose TryParse throws for NumberStyles.Float broke every factor for that type.
• The claim that no double constant changed was wrong. PsiToPascals and
  RevolutionPerMinuteToRadianPerSecond each moved to the adjacent double (closer to the true value)
  in 5.2.0, and IUnit.ToBaseFactor of Psi and RevolutionPerMinute moved with them. That is now
  documented rather than denied.

Mechanism

Integer storage. 5.2.0 emitted each factor as internal static readonly T X = StorageLiteral.Parse<T>(literal, double),
where the fallback T.CreateChecked(double) ran inside the Values<T> static initializer. One value
that does not fit (Tera or CurieToBecquerels for int, Yotta for long) failed the initializer, and
every value for that type failed with it. Each value is now:

internal static T Kilo => ParsedKilo ?? T.CreateChecked(MetricMagnitudes.Kilo);
private static readonly T? ParsedKilo = StorageLiteral.Parse<T>("1e3");

StorageLiteral no longer converts the double at all. It answers null for an integer type or one
that cannot parse the literal, so the initializer cannot throw for those types, and the conversion
happens at the read exactly as the 5.1 factories did it. double and decimal still read a cached
parsed value, and QuantityValueTypeTests still measures 0 bytes allocated.

Square roots. When the value does not convert to a normal double, it is scaled by powers of four
into [1, 4), the root is taken there and scaled back by the matching power of two, so the seed is
always within a factor of two. Reaching the step cap now throws ArithmeticException instead of
returning the estimate. The double, float, Half, and integer primitive paths are unchanged.

π literals. π was computed to 220 places with Machin's formula over integers, checked against a
second Machin-like formula and against the first 100 published digits, and each literal written
correctly rounded to 150 significant digits. Changed: DegreeToRadians, GradianToRadians,
RevolutionToRadians, RevolutionPerMinuteToRadianPerSecond, and
FootLambertToCandelaPerSquareMeter in conversions.json, and TwoPi, DegreesPerRadian, and
RadiansPerDegree in domains.json. No double constant changes, because every error was past the
17th digit.

SEM009. Every generated double constant now carries a d suffix, and SEM009 rejects a literal,
operand, or quotient beyond the range of double, and a non-zero value that rounds to zero.

Parse exceptions. StorageLiteral treats NotSupportedException and ArgumentException from
TryParse as a failed parse. Nothing else is caught.

Magnitude and factor. QuantitiesGenerator now multiplies both when a unit declares both, as
UnitsGenerator already did. No unit declares both today, so no generated output changes.

Risk

• The generated Values<T> members change from fields to properties over private fields. They are
  internal, so no public surface changes. The committed diff is limited to ConversionConstants.g.cs
  (the d suffixes and the holder shape), MetricMagnitudes.g.cs (the holder shape), and
  PhysicalConstants.g.cs (the three π literals and their descriptions).
• A metadata value that 5.2.0 accepted and SEM009 now rejects would stop generating. None of the
  committed metadata is affected.
• Integer and fallback storage types pay a T.CreateChecked per conversion again, as in 5.1.

Testing

Each fix has a test that failed before the change:

• IntegerStorageConversionTests compares int and long factories (FromKilometer, FromCentimeter,
  FromFoot, FromMile, FromHour, FromCelsius, FromFahrenheit, FromCurie) and In(unit)
  against the 5.1 generated expressions with the 5.1 constants, including the OverflowException from
  FromCurie on int and the DivideByZeroException from In(Units.Fahrenheit).
• StorageMathTests covers BigInteger 2^2048 and 10^400 (exact roots), the smallest and largest
  decimal, and zero.
• PiLiteralTests checks all eight π literals to their last digit against π computed in the test.
• AMetricMagnitudeCombinedWithALongFactorIsExact replaces AMetricMagnitudeIsExact, and fails
  when decimal is temporarily sent through the double route.
• GeneratorDiagnosticTests covers SEM009 range rejection, compiles each accepted constant with
  Roslyn, and checks a unit with both a magnitude and a factor.
• StorageLiteralTests runs factories over a custom INumber<T> whose parse throws
  NotSupportedException or ArgumentException.

The solution builds with no warnings. Semantics.Test passes all 1237 tests. Semantics.Cpp.Test
passes 29 of 33, and the 4 skipped tests are the C++ compiler tests that need g++ or clang++.
Regenerating the committed generator output and the alias props leaves no diff beyond what this PR
commits.

🤖 Generated with Claude Code

https://claude.ai/code/session_01K5Bk9UjGdGUtC5C6qK5ZxD

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
90.6% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud