Add canonical init pattern following FixedWidthInteger design

IEEE 754 is THE authoritative binary representation for Float/Double,
not one encoding among many. This makes it fundamentally different from
ASCII (one of many text encodings) and equivalent to FixedWidthInteger
(the canonical binary representation for integers).

Key insight: IEEE 754 should follow the FixedWidthInteger pattern,
not the INCITS 4-1986 ASCII pattern.

Changes:
- Add unlabeled [UInt8] inits: [UInt8](3.14159)
- Add failable inits to Double/Float: Double(bytes: data)
- Follow FixedWidthInteger precedent from Standards package
- Keep namespace API for explicit IEEE 754 reference
- All APIs delegate to authoritative IEEE_754.Binary64/Binary32

Design Philosophy:
- FixedWidthInteger: Canonical transformation → unlabeled inits
- IEEE 754: Canonical transformation → unlabeled inits (NEW)
- ASCII: One-of-many encodings → labeled namespace methods

This enables ergonomic usage matching the canonical nature:
  let bytes = [UInt8](100.0)           // Serialization
  let value = Double(bytes: bytes)      // Deserialization

While preserving explicit namespace access when needed:
  let value = Double.ieee754(bytes)
  let bytes = value.ieee754.bytes()

Tests: All 12 tests passing (added 4 canonical init tests)

Author: coenttb

Sources/IEEE_754/Double+IEEE_754.swift

@@ -25,6 +25,35 @@ extension Double {
     }
 }
 
+// MARK: - Canonical Deserialization
+
+extension Double {
+    /// Creates Double from IEEE 754 binary64 bytes
+    ///
+    /// This is the canonical deserialization for Double, following the
+    /// FixedWidthInteger pattern. IEEE 754 is THE authoritative representation
+    /// for floating-point values.
+    ///
+    /// Delegates to `IEEE_754.Binary64.value(from:endianness:)`.
+    ///
+    /// - Parameters:
+    ///   - bytes: 8-byte array in IEEE 754 binary64 format
+    ///   - endianness: Byte order of input bytes
+    /// - Returns: nil if bytes.count ≠ 8
+    ///
+    /// Example:
+    /// ```swift
+    /// let value = Double(bytes: data)
+    /// let value = Double(bytes: data, endianness: .big)
+    /// ```
+    public init?(bytes: [UInt8], endianness: [UInt8].Endianness = .little) {
+        guard let value = IEEE_754.Binary64.value(from: bytes, endianness: endianness) else {
+            return nil
+        }
+        self = value
+    }
+}
+
 // MARK: - Type-level Methods
 
 extension Double {

Sources/IEEE_754/Float+IEEE_754.swift

@@ -25,6 +25,35 @@ extension Float {
     }
 }
 
+// MARK: - Canonical Deserialization
+
+extension Float {
+    /// Creates Float from IEEE 754 binary32 bytes
+    ///
+    /// This is the canonical deserialization for Float, following the
+    /// FixedWidthInteger pattern. IEEE 754 is THE authoritative representation
+    /// for floating-point values.
+    ///
+    /// Delegates to `IEEE_754.Binary32.value(from:endianness:)`.
+    ///
+    /// - Parameters:
+    ///   - bytes: 4-byte array in IEEE 754 binary32 format
+    ///   - endianness: Byte order of input bytes
+    /// - Returns: nil if bytes.count ≠ 4
+    ///
+    /// Example:
+    /// ```swift
+    /// let value = Float(bytes: data)
+    /// let value = Float(bytes: data, endianness: .big)
+    /// ```
+    public init?(bytes: [UInt8], endianness: [UInt8].Endianness = .little) {
+        guard let value = IEEE_754.Binary32.value(from: bytes, endianness: endianness) else {
+            return nil
+        }
+        self = value
+    }
+}
+
 // MARK: - Type-level Methods
 
 extension Float {

Sources/IEEE_754/[UInt8]+IEEE_754.swift

@@ -106,3 +106,45 @@ extension [UInt8].IEEE754 {
         IEEE_754.Binary32.value(from: bytes, endianness: endianness)
     }
 }
+
+// MARK: - Canonical [UInt8] Initializers
+
+extension [UInt8] {
+    /// Creates byte array from Double using IEEE 754 binary64 format
+    ///
+    /// This is the canonical binary serialization for Double, following the
+    /// FixedWidthInteger pattern. IEEE 754 is THE authoritative representation
+    /// for floating-point values, not one encoding among many.
+    ///
+    /// - Parameters:
+    ///   - value: Double to serialize
+    ///   - endianness: Byte order (defaults to little-endian)
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes = [UInt8](3.14159)                    // Little-endian
+    /// let bytes = [UInt8](3.14159, endianness: .big)  // Big-endian (network order)
+    /// ```
+    public init(_ value: Double, endianness: Endianness = .little) {
+        self = IEEE_754.Binary64.bytes(from: value, endianness: endianness)
+    }
+
+    /// Creates byte array from Float using IEEE 754 binary32 format
+    ///
+    /// This is the canonical binary serialization for Float, following the
+    /// FixedWidthInteger pattern. IEEE 754 is THE authoritative representation
+    /// for floating-point values, not one encoding among many.
+    ///
+    /// - Parameters:
+    ///   - value: Float to serialize
+    ///   - endianness: Byte order (defaults to little-endian)
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes = [UInt8](Float(3.14))                    // Little-endian
+    /// let bytes = [UInt8](Float(3.14), endianness: .big)  // Big-endian (network order)
+    /// ```
+    public init(_ value: Float, endianness: Endianness = .little) {
+        self = IEEE_754.Binary32.bytes(from: value, endianness: endianness)
+    }
+}

Tests/IEEE_754_Tests/IEEE_754_Tests.swift

@@ -17,6 +17,15 @@ struct Binary64Tests {
         #expect(restored == original)
     }
 
+    @Test("Double canonical init round-trip")
+    func doubleCanonicalInitRoundTrip() {
+        let original: Double = 3.14159265358979323846
+        let bytes = [UInt8](original)
+        let restored = Double(bytes: bytes)
+
+        #expect(restored == original)
+    }
+
     @Test("Double big-endian serialization")
     func doubleBigEndian() {
         let value: Double = 3.14159
@@ -26,6 +35,15 @@ struct Binary64Tests {
         #expect(restored == value)
     }
 
+    @Test("Double canonical init big-endian")
+    func doubleCanonicalInitBigEndian() {
+        let value: Double = 3.14159
+        let bytes = [UInt8](value, endianness: .big)
+        let restored = Double(bytes: bytes, endianness: .big)
+
+        #expect(restored == value)
+    }
+
     @Test("Double special values")
     func doubleSpecialValues() {
         // Zero
@@ -53,6 +71,15 @@ struct Binary32Tests {
         #expect(restored == original)
     }
 
+    @Test("Float canonical init round-trip")
+    func floatCanonicalInitRoundTrip() {
+        let original: Float = 3.14159
+        let bytes = [UInt8](original)
+        let restored = Float(bytes: bytes)
+
+        #expect(restored == original)
+    }
+
     @Test("Float big-endian serialization")
     func floatBigEndian() {
         let value: Float = 3.14
@@ -62,6 +89,15 @@ struct Binary32Tests {
         #expect(restored == value)
     }
 
+    @Test("Float canonical init big-endian")
+    func floatCanonicalInitBigEndian() {
+        let value: Float = 3.14
+        let bytes = [UInt8](value, endianness: .big)
+        let restored = Float(bytes: bytes, endianness: .big)
+
+        #expect(restored == value)
+    }
+
     @Test("Float special values")
     func floatSpecialValues() {
         // Zero