Refactor Domain with RFC 1035 and 1123 extensions

- Split Domain implementation into separate RFC extension files
- Add Domain+RFC1035.swift for RFC 1035 support
- Add Domain+RFC1123.swift for RFC 1123 support
- Update main Domain.swift implementation

Author: coenttb

Sources/Domain/Domain+RFC1035.swift

@@ -0,0 +1,22 @@
+import Foundation
+import RFC_1035
+
+extension Domain {
+    // Forward conversion already exists in Domain.swift
+    // public init(rfc1035: RFC_1035.Domain) throws
+}
+
+extension RFC_1035.Domain {
+    /// Initialize from Domain
+    ///
+    /// Enables round-trip conversion between Domain and RFC_1035.Domain.
+    ///
+    /// - Parameter domain: The Domain to convert
+    /// - Throws: If the Domain doesn't have a valid RFC 1035 representation
+    public init(_ domain: Domain) throws {
+        guard let rfc1035 = domain.rfc1035 else {
+            throw Domain.DomainError.conversionFailure
+        }
+        self = rfc1035
+    }
+}

Sources/Domain/Domain+RFC1123.swift

@@ -0,0 +1,21 @@
+import Foundation
+import RFC_1123
+
+extension Domain {
+    // Forward conversion already exists in Domain.swift
+    // public init(rfc1123: RFC_1123.Domain)
+}
+
+extension RFC_1123.Domain {
+    /// Initialize from Domain
+    ///
+    /// Enables round-trip conversion between Domain and RFC_1123.Domain.
+    ///
+    /// - Parameter domain: The Domain to convert
+    /// - Returns: The RFC 1123 domain representation
+    /// - Note: Since RFC_5321.Domain is RFC_1123.Domain, this always succeeds
+    public init(_ domain: Domain) {
+        // RFC 5321 uses RFC 1123 domains directly, so we can always get an RFC 1123 representation
+        self = domain.rfc5321
+    }
+}

Sources/Domain/Domain.swift

@@ -52,21 +52,19 @@ extension Domain {
     }
 
     /// Initialize from RFC1123
-    public init(rfc1123: RFC_1123.Domain) throws {
+    /// Note: RFC 5321 reuses RFC 1123 domain definitions, so this conversion is infallible
+    public init(rfc1123: RFC_1123.Domain) {
         self.rfc1035 = nil  // RFC1123 may not be RFC1035 compliant
         self.rfc1123 = rfc1123
-        self.rfc5321 = try {
-            guard let domain = try? RFC_5321.Domain(rfc1123.name) else {
-                throw DomainError.conversionFailure
-            }
-            return domain
-        }()
+        // RFC 5321 uses RFC 1123 domains directly (type alias), so this is safe
+        self.rfc5321 = rfc1123
     }
 
     /// Initialize from RFC_5321.Domain
+    /// Note: RFC_5321.Domain is actually a type alias for RFC_1123.Domain
     public init(rfc5321: RFC_5321.Domain) {
         self.rfc1035 = nil  // RFC_5321.Domain may not be RFC1035 compliant
-        self.rfc1123 = nil  // RFC_5321.Domain may not be RFC1123 compliant
+        self.rfc1123 = rfc5321  // RFC 5321 uses RFC 1123 domains
         self.rfc5321 = rfc5321
     }
 }