Add Swifty nan() function with static .c namespace

Improves ergonomics of nan() function creation by:
- Adding String-based nan() wrapper to Double.C and Float.C
- Adding static .c property to Double and Float for type-level access
- Enabling idiomatic syntax: Double.c.nan() and Float.c.nan()

API Changes:
- Double.C.nan(_ tag: String = "") -> Double
- Float.C.nan(_ tag: String = "") -> Float
- Double.c (static) -> C.Type
- Float.c (static) -> C.Type

Usage:
  // Simple NaN
  let nan1 = Double.c.nan()

  // NaN with diagnostic payload
  let nan2 = Double.c.nan("overflow")
  let nan3 = Float.c.nan("underflow")

Authoritative API (ISO_9899.Math.nan) remains unchanged for standards
compliance. The Swifty wrapper eliminates need for .withCString closures
while maintaining zero-overhead delegation via @_transparent.

Tests: Added 8 comprehensive tests in NaNSwiftyAPITests.swift
All 183 tests pass

Author: coenttb

Sources/ISO 9899/Double+ISO_9899.swift

@@ -20,6 +20,9 @@ extension Double {
     /// let sine = x.c.sin                // 0.90929742...
     /// let log = x.c.log                 // 0.693147180...
     /// let abs = (-x).c.abs              // 2.0
+    ///
+    /// // Static methods
+    /// let nan = Double.c.nan("overflow")  // NaN with payload
     /// ```
     ///
     /// ## See Also
@@ -29,6 +32,20 @@ extension Double {
         C(value: self)
     }
 
+    /// Static access to C standard library math type-level functions via `.c` namespace
+    ///
+    /// Provides ergonomic access to type-level C math functions like `nan()`.
+    ///
+    /// ## Usage
+    ///
+    /// ```swift
+    /// let nan = Double.c.nan()              // Plain NaN
+    /// let tagged = Double.c.nan("overflow") // NaN with diagnostic payload
+    /// ```
+    public static var c: C.Type {
+        C.self
+    }
+
     /// C standard library math operations namespace for Double
     ///
     /// Provides ergonomic instance access to C math functions.
@@ -441,6 +458,31 @@ extension Double.C {
 // MARK: - Manipulation Functions (Section 7.12.11)
 
 extension Double.C {
+    /// Create a quiet NaN with optional diagnostic payload
+    ///
+    /// Creates a quiet NaN value with an optional string tag that encodes a payload
+    /// in the NaN's trailing fraction field. This can be useful for debugging or
+    /// tracking the origin of NaN values.
+    ///
+    /// The payload interpretation is implementation-defined. Most implementations
+    /// either ignore the tag or interpret it as an integer.
+    ///
+    /// Delegates to ``ISO_9899/Math/nan(_:)``
+    ///
+    /// - Parameter tag: Optional string tag for NaN payload (defaults to empty string)
+    /// - Returns: A quiet NaN value
+    ///
+    /// ## Example
+    /// ```swift
+    /// let nan1 = Double.c.nan()                    // Plain NaN
+    /// let nan2 = Double.c.nan("overflow")          // NaN with diagnostic tag
+    /// let nan3 = Double.c.nan("division-by-zero")  // Different payload
+    /// ```
+    @_transparent
+    public static func nan(_ tag: String = "") -> Double {
+        tag.withCString { ISO_9899.Math.nan($0) }
+    }
+
     /// Returns self with the sign of another value
     ///
     /// Returns a value with the magnitude of self and the sign of `other`.

Sources/ISO 9899/Float+ISO_9899.swift

@@ -20,6 +20,9 @@ extension Float {
     /// let sine = x.c.sin                // 0.90929742...
     /// let log = x.c.log                 // 0.693147180...
     /// let abs = (-x).c.abs              // 2.0
+    ///
+    /// // Static methods
+    /// let nan = Float.c.nan("overflow")   // NaN with payload
     /// ```
     ///
     /// ## See Also
@@ -29,6 +32,20 @@ extension Float {
         C(value: self)
     }
 
+    /// Static access to C standard library math type-level functions via `.c` namespace
+    ///
+    /// Provides ergonomic access to type-level C math functions like `nan()`.
+    ///
+    /// ## Usage
+    ///
+    /// ```swift
+    /// let nan = Float.c.nan()              // Plain NaN
+    /// let tagged = Float.c.nan("overflow") // NaN with diagnostic payload
+    /// ```
+    public static var c: C.Type {
+        C.self
+    }
+
     /// C standard library math operations namespace for Float
     ///
     /// Provides ergonomic instance access to C math functions.
@@ -441,6 +458,31 @@ extension Float.C {
 // MARK: - Manipulation Functions (Section 7.12.11)
 
 extension Float.C {
+    /// Create a quiet NaN with optional diagnostic payload
+    ///
+    /// Creates a quiet NaN value with an optional string tag that encodes a payload
+    /// in the NaN's trailing fraction field. This can be useful for debugging or
+    /// tracking the origin of NaN values.
+    ///
+    /// The payload interpretation is implementation-defined. Most implementations
+    /// either ignore the tag or interpret it as an integer.
+    ///
+    /// Delegates to ``ISO_9899/Math/nanf(_:)``
+    ///
+    /// - Parameter tag: Optional string tag for NaN payload (defaults to empty string)
+    /// - Returns: A quiet NaN value
+    ///
+    /// ## Example
+    /// ```swift
+    /// let nan1 = Float.c.nan()                    // Plain NaN
+    /// let nan2 = Float.c.nan("overflow")          // NaN with diagnostic tag
+    /// let nan3 = Float.c.nan("division-by-zero")  // Different payload
+    /// ```
+    @_transparent
+    public static func nan(_ tag: String = "") -> Float {
+        tag.withCString { ISO_9899.Math.nanf($0) }
+    }
+
     /// Returns self with the sign of another value
     ///
     /// Returns a value with the magnitude of self and the sign of `other`.

Tests/ISO 9899 Tests/NaNSwiftyAPITests.swift

@@ -0,0 +1,88 @@
+@testable import ISO_9899
+import Testing
+
+@Suite("NaN Creation - Swifty API")
+struct NaNSwiftyAPITests {
+
+    @Test("Double.c.nan() creates NaN")
+    func doubleNanBasic() {
+        let result = Double.c.nan()
+        #expect(result.isNaN)
+        #expect(result.c.isNaN)
+    }
+
+    @Test("Double.c.nan(tag) creates NaN with payload")
+    func doubleNanWithTag() {
+        let result = Double.c.nan("overflow")
+        #expect(result.isNaN)
+        #expect(result.c.isNaN)
+    }
+
+    @Test("Different tags produce different bit patterns")
+    func doubleNanDifferentPayloads() {
+        let nan1 = Double.c.nan("")
+        let nan2 = Double.c.nan("1")
+        let nan3 = Double.c.nan("2")
+        
+        // All should be NaN
+        #expect(nan1.isNaN)
+        #expect(nan2.isNaN)
+        #expect(nan3.isNaN)
+        
+        // But with different bit patterns (payloads)
+        // Note: Empty string might produce same as some default
+        #expect(nan2.bitPattern != nan3.bitPattern)
+    }
+    
+    @Test("Float.c.nan() creates NaN")
+    func floatNanBasic() {
+        let result = Float.c.nan()
+        #expect(result.isNaN)
+        #expect(result.c.isNaN)
+    }
+
+    @Test("Float.c.nan(tag) creates NaN with payload")
+    func floatNanWithTag() {
+        let result = Float.c.nan("underflow")
+        #expect(result.isNaN)
+        #expect(result.c.isNaN)
+    }
+
+    @Test("NaN with payload has correct classification")
+    func nanClassification() {
+        let result = Double.c.nan("test")
+        #expect(result.c.classification == .nan)
+        #expect(result.c.isNaN == true)
+        #expect(result.c.isFinite == false)
+        #expect(result.c.isInfinite == false)
+        #expect(result.c.isNormal == false)
+    }
+    
+    @Test("NaN comparisons work correctly")
+    func nanComparisons() {
+        let nan1 = Double.c.nan("a")
+        let nan2 = Double.c.nan("b")
+        
+        // NaN comparisons should return false
+        #expect(nan1.c.isGreater(than: nan2) == false)
+        #expect(nan1.c.isLess(than: nan2) == false)
+        #expect(nan1.c.isNotEqual(to: nan2) == false)
+        
+        // But they should be unordered
+        #expect(nan1.c.isUnordered(with: nan2) == true)
+        #expect(nan1.c.isUnordered(with: 5.0) == true)
+    }
+    
+    @Test("Authoritative API still works")
+    func authoritativeAPICompatibility() {
+        let swiftyNaN = Double.c.nan("auth")
+        let authNaN = "auth".withCString { ISO_9899.Math.nan($0) }
+        
+        // Both should be NaN
+        #expect(swiftyNaN.isNaN)
+        #expect(ISO_9899.Math.isnan(authNaN))
+        
+        // And should have same bit pattern
+        #expect(swiftyNaN.bitPattern == authNaN.bitPattern)
+    }
+}