Fix Swift 6.4 build errors from state handler refactor

Two issues introduced by apple#132 on the current toolchain:

1. StateHandler+MTLBuffer.swift: insertAll(into: inout AsyncMutableViews)
   triggers lifetime-dependent-variable-escapes-scope. Fixed with
   _overrideLifetime(views, borrowing: self) after each insert — this
   tells the compiler the views' lifetime is tied to self (which owns
   the MTLBuffers backing the stored pointers), not to the loop-local
   AsyncMutableValue.

2. CoreAISequentialEngine.swift: Dead code referencing removed properties
   (keyCache, valueCache, currentKVCapacity, keyCacheDescriptor,
   valueCacheDescriptor). Deleted ensureKVCapacity(), copyCache(), and
   zeroFill() — all superseded by kvCache: SyncStateHandler.

Author: stikves

swift/Sources/CoreAILanguageModels/Handlers/StateHandler+MTLBuffer.swift

@@ -49,12 +49,13 @@ public struct FixedMTLBufferState {
     }
 
     /// Insert all states into AsyncMutableViews for pipelined encoding.
-    public func insertAll(into views: inout InferenceFunction.AsyncMutableViews) {
+    func insertAll(into views: inout InferenceFunction.AsyncMutableViews) {
         for (name, buffer, scalarType, shape, strides) in bindings {
             var value = unsafe InferenceFunction.AsyncMutableValue(
                 unsafeBuffer: buffer, byteOffset: 0,
                 scalarType: scalarType, shape: shape, strides: strides)
             views.insert(&value, for: name)
+            views = unsafe _overrideLifetime(views, borrowing: self)
         }
     }
 

swift/Sources/CoreAILanguageModels/InferenceEngines/CoreAISequentialEngine.swift

@@ -475,84 +475,7 @@ public final class CoreAISequentialEngine: InferenceEngine, @unchecked Sendable
         cleanupSpan.end()
     }
 
-    // MARK: - KV Cache (dynamic growth)
-
-    private func ensureKVCapacity(forContextLength needed: Int) throws {
-        guard needed > currentKVCapacity else { return }
-        guard needed <= config.maxContextLength else {
-            throw InferenceRuntimeError.invalidState(
-                "Context length \(needed) exceeds maximum \(config.maxContextLength)")
-        }
-
-        var newCapacity = currentKVCapacity
-        while newCapacity < needed { newCapacity *= 2 }
-        newCapacity = min(newCapacity, config.maxContextLength)
-
-        let resolvedKeyDesc = keyCacheDescriptor.resolvingDynamicDimensions(
-            keyCacheDescriptor.shape.map { $0 < 0 ? newCapacity : $0 })
-        let resolvedValueDesc = valueCacheDescriptor.resolvingDynamicDimensions(
-            valueCacheDescriptor.shape.map { $0 < 0 ? newCapacity : $0 })
-
-        var newKeyCache = NDArray(descriptor: resolvedKeyDesc)
-        var newValueCache = NDArray(descriptor: resolvedValueDesc)
-        _ = newKeyCache.mutableRawView()
-        _ = newValueCache.mutableRawView()
-
-        try Self.copyCache(from: keyCache, to: &newKeyCache)
-        try Self.copyCache(from: valueCache, to: &newValueCache)
-
-        CLILogger.log("KV cache grew: \(currentKVCapacity) → \(newCapacity)")
-        keyCache = newKeyCache
-        valueCache = newValueCache
-        currentKVCapacity = newCapacity
-    }
-
-    private static func copyCache(from source: NDArray, to destination: inout NDArray) throws {
-        let srcShape = source.shape
-        let dstShape = destination.shape
-        guard let headDim = srcShape.last else {
-            throw InferenceRuntimeError.invalidState("KV cache has empty shape — cannot copy")
-        }
-        let seqDim = KVCacheFactory.detectSequenceDim(shape: srcShape)
-
-        // Number of independent blocks before the sequence dimension (L * B * H or B * H)
-        let numBlocks = srcShape[..<seqDim].reduce(1, *)
-        let oldSeqLen = srcShape[seqDim]
-        let copySize = oldSeqLen * headDim
-
-        // Strides in elements for the sequence block
-        let srcBlockStride = srcShape[seqDim...].reduce(1, *)  // S_old * D
-        let dstBlockStride = dstShape[seqDim...].reduce(1, *)  // S_new * D
-
-        source.view(as: LogitsScalarType.self).withUnsafePointer { srcPtr, _, _ in
-            let dstView = destination.mutableView(as: LogitsScalarType.self)
-            dstView.withUnsafeMutablePointer { dstPtr, _, _ in
-                for block in 0..<numBlocks {
-                    let srcOff = block * srcBlockStride
-                    let dstOff = block * dstBlockStride
-                    dstPtr.advanced(by: dstOff).update(
-                        from: srcPtr.advanced(by: srcOff), count: copySize)
-                }
-            }
-        }
-    }
-
     // MARK: - Helpers
-
-    private func zeroFill(_ array: inout NDArray) {
-        let count = array.shape.reduce(1, *)
-        let view = array.mutableView(as: LogitsScalarType.self)
-        // Inlined constant write — under -Onone, fillNDArray's
-        // `(Int) -> LogitsScalarType` closure is invoked per element (no inlining),
-        // which made zeroing the KV cache (~14.7M elements for a 32K-context
-        // Qwen3) take ~6 seconds per `reset()`. Direct loop keeps this in
-        // the few-ms range even unoptimized; under -O it lowers to memset.
-        view.withUnsafeMutablePointer { ptr, _, _ in
-            for i in 0..<count {
-                ptr[i] = 0
-            }
-        }
-    }
 }
 
 extension CoreAISequentialEngine {