Add direct .bytes() methods to Double and Float

Since IEEE 754 is THE canonical transformation (not one of many),
add direct instance methods matching FixedWidthInteger pattern.
This is additive - all existing namespace methods remain.

Changes:
- Add Double.bytes(endianness:) instance method
- Add Float.bytes(endianness:) instance method
- Both delegate to authoritative IEEE_754.Binary64/Binary32 implementations
- Add 4 new tests demonstrating direct access pattern

Multiple ergonomic options now available:
- value.bytes() - NEW direct canonical (like FixedWidthInteger)
- value.ieee754.bytes() - existing namespace access
- [UInt8](value) - existing unlabeled init
- Double(bytes: data) - existing canonical init

All patterns work and delegate to the same authoritative implementation.

Tests: All 16 tests passing (12 existing + 4 new)

Author: coenttb

Sources/IEEE_754/Double+IEEE_754.swift

@@ -54,6 +54,29 @@ extension Double {
     }
 }
 
+// MARK: - Canonical Serialization
+
+extension Double {
+    /// Returns IEEE 754 binary64 byte representation
+    ///
+    /// Canonical serialization following FixedWidthInteger pattern.
+    /// IEEE 754 is THE authoritative representation for floating-point values.
+    ///
+    /// Delegates to `IEEE_754.Binary64.bytes(from:endianness:)`.
+    ///
+    /// - Parameter endianness: Byte order (little or big)
+    /// - Returns: 8-byte array in IEEE 754 binary64 format
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes = value.bytes()
+    /// let bytes = value.bytes(endianness: .big)
+    /// ```
+    public func bytes(endianness: [UInt8].Endianness = .little) -> [UInt8] {
+        IEEE_754.Binary64.bytes(from: self, endianness: endianness)
+    }
+}
+
 // MARK: - Type-level Methods
 
 extension Double {

Sources/IEEE_754/Float+IEEE_754.swift

@@ -54,6 +54,29 @@ extension Float {
     }
 }
 
+// MARK: - Canonical Serialization
+
+extension Float {
+    /// Returns IEEE 754 binary32 byte representation
+    ///
+    /// Canonical serialization following FixedWidthInteger pattern.
+    /// IEEE 754 is THE authoritative representation for floating-point values.
+    ///
+    /// Delegates to `IEEE_754.Binary32.bytes(from:endianness:)`.
+    ///
+    /// - Parameter endianness: Byte order (little or big)
+    /// - Returns: 4-byte array in IEEE 754 binary32 format
+    ///
+    /// Example:
+    /// ```swift
+    /// let bytes = value.bytes()
+    /// let bytes = value.bytes(endianness: .big)
+    /// ```
+    public func bytes(endianness: [UInt8].Endianness = .little) -> [UInt8] {
+        IEEE_754.Binary32.bytes(from: self, endianness: endianness)
+    }
+}
+
 // MARK: - Type-level Methods
 
 extension Float {

Tests/IEEE_754_Tests/IEEE_754_Tests.swift

@@ -44,6 +44,24 @@ struct Binary64Tests {
         #expect(restored == value)
     }
 
+    @Test("Double direct bytes method")
+    func doubleDirectBytes() {
+        let value: Double = 2.71828
+        let bytes = value.bytes()
+        let restored = Double(bytes: bytes)
+
+        #expect(restored == value)
+    }
+
+    @Test("Double direct bytes big-endian")
+    func doubleDirectBytesBigEndian() {
+        let value: Double = 1.41421
+        let bytes = value.bytes(endianness: .big)
+        let restored = Double(bytes: bytes, endianness: .big)
+
+        #expect(restored == value)
+    }
+
     @Test("Double special values")
     func doubleSpecialValues() {
         // Zero
@@ -98,6 +116,24 @@ struct Binary32Tests {
         #expect(restored == value)
     }
 
+    @Test("Float direct bytes method")
+    func floatDirectBytes() {
+        let value: Float = 2.71828
+        let bytes = value.bytes()
+        let restored = Float(bytes: bytes)
+
+        #expect(restored == value)
+    }
+
+    @Test("Float direct bytes big-endian")
+    func floatDirectBytesBigEndian() {
+        let value: Float = 1.41421
+        let bytes = value.bytes(endianness: .big)
+        let restored = Float(bytes: bytes, endianness: .big)
+
+        #expect(restored == value)
+    }
+
     @Test("Float special values")
     func floatSpecialValues() {
         // Zero