perf/feat: port JSONChunkAssembler byte-scan + SQLValue.toAny() from C#

JSONChunkAssembler (mirrors C# v1.4.6):
- Replace String-based pending buffer with Data
- feed() appends UTF-8 bytes directly (no String concat or re-encoding)
- Scan bytes by index using ASCII constants — safe in UTF-8 since
  {, }, ", \ are all single-byte
- results.append(pending[start...i]) is a zero-copy Data slice;
  no String(combined[start...i]) + Data(jsonStr.utf8) double-copy
- Eliminates one String allocation per chunk and one re-encoding per found object

SQLValue.toAny() (mirrors C# v1.3.8 ToClrObject()):
- Returns the unwrapped underlying Swift value as Any?, nil for .null
- Useful for JSON serialization, generic containers, and
  any code that needs the value without switching on every case

C# fixes NOT ported (not applicable to Swift):
- EnvChange string-type detection: Swift switch already handles each type
  correctly and ignores unknowns — the bug did not exist here
- QueryStreamAsync lastBufEnd: Swift uses NIO frame-based delivery,
  no raw byte buffer management
- FillDataTableAsync / DataTable: System.Data is .NET-only

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: vkuttyp

Sources/CosmoSQLCore/JSONChunkAssembler.swift

@@ -24,59 +24,67 @@ import Foundation
 /// }
 /// ```
 public struct JSONChunkAssembler {
-    private var pending:  String = ""   // partial JSON object buffered across chunks
-    private var depth:    Int    = 0    // current `{` nesting depth
-    private var inString: Bool   = false
-    private var escaped:  Bool   = false
+    // Working buffer — accumulated UTF-8 bytes across calls.
+    // Using Data instead of String avoids per-chunk String concatenation and
+    // the subsequent re-encoding when extracting found objects.
+    private var pending:  Data = Data()
+    private var depth:    Int  = 0      // current { nesting depth
+    private var inString: Bool = false
+    private var escaped:  Bool = false
+
+    // ASCII byte constants — all single-byte, safe to scan in UTF-8.
+    private static let openBrace:  UInt8 = 0x7B  // {
+    private static let closeBrace: UInt8 = 0x7D  // }
+    private static let quote:      UInt8 = 0x22  // "
+    private static let backslash:  UInt8 = 0x5C  // \
 
     public init() {}
 
     /// Feed a text chunk and return all complete JSON objects found.
     ///
     /// Each returned `Data` value is valid UTF-8 JSON representing one top-level object.
     public mutating func feed(_ chunk: String) -> [Data] {
-        let combined = pending.isEmpty ? chunk : pending + chunk
-        pending = ""
+        // Append UTF-8 bytes directly — one allocation, no intermediate String copy.
+        pending.append(contentsOf: chunk.utf8)
 
-        var results:  [Data]   = []
-        var objStart: String.Index? = nil
-        var i = combined.startIndex
+        var results:  [Data] = []
+        var objStart: Int?   = nil
 
-        while i < combined.endIndex {
-            let ch = combined[i]
+        for i in 0 ..< pending.count {
+            let ch = pending[i]
 
             if escaped {
                 escaped = false
-            } else if inString {
-                switch ch {
-                case "\\": escaped  = true
-                case "\"": inString = false
-                default:   break
-                }
-            } else {
-                switch ch {
-                case "{":
-                    if depth == 0 { objStart = i }
-                    depth += 1
-                case "}":
-                    depth -= 1
-                    if depth == 0, let start = objStart {
-                        let jsonStr = String(combined[start...i])
-                        results.append(Data(jsonStr.utf8))
-                        objStart = nil
-                    }
-                case "\"":
-                    inString = true
-                default:
-                    break
+                continue
+            }
+            if inString {
+                if      ch == Self.backslash { escaped  = true  }
+                else if ch == Self.quote     { inString = false }
+                continue
+            }
+            switch ch {
+            case Self.openBrace:
+                if depth == 0 { objStart = i }
+                depth += 1
+            case Self.closeBrace:
+                depth -= 1
+                if depth == 0, let start = objStart {
+                    // Zero-copy slice into the existing buffer — no re-encoding.
+                    results.append(pending[start ... i])
+                    objStart = nil
                 }
+            case Self.quote:
+                inString = true
+            default:
+                break
             }
-            i = combined.index(after: i)
         }
 
-        // Buffer any partial object for the next call
+        // Retain only the partial object (if any) for the next call.
         if let start = objStart {
-            pending = String(combined[start...])
+            pending = Data(pending[start...])
+        } else {
+            pending = Data()
         }
 
         return results

Sources/CosmoSQLCore/SQLValue.swift

@@ -77,6 +77,29 @@ public extension SQLValue {
         default: return nil
         }
     }
+
+    /// Returns the underlying Swift value as `Any`, or `nil` for `.null`.
+    ///
+    /// Useful for JSON serialization, generic containers, and any code that needs
+    /// the unwrapped value without pattern-matching on each `SQLValue` case.
+    func toAny() -> Any? {
+        switch self {
+        case .null:           return nil
+        case .bool(let v):    return v
+        case .int(let v):     return v
+        case .int8(let v):    return v
+        case .int16(let v):   return v
+        case .int32(let v):   return v
+        case .int64(let v):   return v
+        case .float(let v):   return v
+        case .double(let v):  return v
+        case .decimal(let v): return v
+        case .string(let v):  return v
+        case .bytes(let v):   return v
+        case .uuid(let v):    return v
+        case .date(let v):    return v
+        }
+    }
 }
 
 // MARK: - ExpressibleBy literals