feat: add platform shells, CLI, formatting, plugins, tests, and benchmarks

Phase 4 — Platform shells:
- calcpad-macos/: SwiftUI two-column editor with Rust FFI bridge (16 files)
- calcpad-windows/: iced GUI with Windows 11 Fluent theme (7 files, 13 tests)
- calcpad-web/: React 18 + CodeMirror 6 + WASM Worker + PWA (20 files)
- calcpad-cli/: clap-based CLI with expression eval, pipe/stdin, JSON/CSV
  output, and interactive REPL with rustyline history

Phase 5 — Engine modules:
- formatting/: answer formatting (decimal/scientific/SI notation, thousands
  separators, currency), line type classification, clipboard values (93 tests)
- plugins/: CalcPadPlugin trait, PluginRegistry, Rhai scripting stub (43 tests)
- benches/: criterion benchmarks (single-line, 100/500-line sheets, DAG, incremental)
- tests/sheet_scenarios.rs: 20 real-world integration tests
- tests/proptest_fuzz.rs: 12 property-based fuzz tests

771 tests passing across workspace, 0 failures.

calcpad-macos/Sources/CalcPad/Engine/CalculationEngine.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+/// Protocol for a calculation engine that evaluates text expressions.
+/// The primary implementation is RustCalculationEngine (FFI bridge to calcpad-engine).
+/// StubCalculationEngine is provided for testing without the Rust library.
+protocol CalculationEngine: Sendable {
+    /// Evaluate a single line expression and return the result string, or nil for blank/comment lines.
+    func evaluateLine(_ line: String) -> LineResult
+
+    /// Evaluate an entire sheet (multi-line text) and return results for each line.
+    func evaluateSheet(_ text: String) -> [LineResult]
+}
+
+/// Stub engine for testing that handles basic arithmetic (+, -, *, /).
+/// Used when the Rust engine library is not available.
+final class StubCalculationEngine: CalculationEngine {
+
+    func evaluateLine(_ line: String) -> LineResult {
+        evaluateSingleLine(line, lineNumber: 1)
+    }
+
+    func evaluateSheet(_ text: String) -> [LineResult] {
+        let lines = text.components(separatedBy: "\n")
+        return lines.enumerated().map { index, line in
+            evaluateSingleLine(line, lineNumber: index + 1)
+        }
+    }
+
+    private func evaluateSingleLine(_ line: String, lineNumber: Int) -> LineResult {
+        let trimmed = line.trimmingCharacters(in: .whitespaces)
+
+        // Blank lines produce no result
+        guard !trimmed.isEmpty else {
+            return LineResult(id: lineNumber, expression: line, result: nil, isError: false)
+        }
+
+        // Comment lines (starting with // or #) produce no result
+        if trimmed.hasPrefix("//") || trimmed.hasPrefix("#") {
+            return LineResult(id: lineNumber, expression: line, result: nil, isError: false)
+        }
+
+        // Convert integer literals to floating-point so division produces decimals.
+        // NSExpression does integer division for "7 / 2" -> 3, but we want 3.5.
+        let floatExpr = trimmed.replacingOccurrences(
+            of: #"\b(\d+)\b"#,
+            with: "$1.0",
+            options: .regularExpression
+        )
+
+        // Try to evaluate as a basic arithmetic expression
+        do {
+            let expr = NSExpression(format: floatExpr)
+            if let value = expr.expressionValue(with: nil, context: nil) as? NSNumber {
+                let doubleValue = value.doubleValue
+                let formatted = String(format: "%g", doubleValue)
+                return LineResult(id: lineNumber, expression: line, result: formatted, isError: false)
+            }
+        }
+
+        return LineResult(id: lineNumber, expression: line, result: "Error", isError: true)
+    }
+}

calcpad-macos/Sources/CalcPad/Engine/FFIModels.swift

@@ -0,0 +1,107 @@
+import Foundation
+
+/// JSON response from `calcpad_eval_line` — wraps a single `CalcResult`.
+struct FFIResponse: Decodable {
+    let schemaVersion: String
+    let result: FFICalcResult
+
+    enum CodingKeys: String, CodingKey {
+        case schemaVersion = "schema_version"
+        case result
+    }
+}
+
+/// JSON response from `calcpad_eval_sheet` — wraps an array of `CalcResult`.
+struct FFISheetResponse: Decodable {
+    let schemaVersion: String
+    let results: [FFICalcResult]
+
+    enum CodingKeys: String, CodingKey {
+        case schemaVersion = "schema_version"
+        case results
+    }
+}
+
+/// A complete calculation result returned by the Rust engine.
+struct FFICalcResult: Decodable {
+    let value: FFICalcValue
+    let metadata: FFIResultMetadata
+}
+
+/// Metadata attached to every evaluation result.
+struct FFIResultMetadata: Decodable {
+    let span: FFISpan
+    let resultType: String
+    let display: String
+    let rawValue: Double?
+
+    enum CodingKeys: String, CodingKey {
+        case span
+        case resultType = "result_type"
+        case display
+        case rawValue = "raw_value"
+    }
+}
+
+/// Source span (byte offsets).
+struct FFISpan: Decodable {
+    let start: Int
+    let end: Int
+}
+
+/// Tagged union of possible calculation values.
+/// Rust serializes with `#[serde(tag = "kind")]`.
+enum FFICalcValue: Decodable {
+    case number(value: Double)
+    case unitValue(value: Double, unit: String)
+    case currencyValue(amount: Double, currency: String)
+    case dateTime(date: String)
+    case timeDelta(days: Int64, description: String)
+    case boolean(value: Bool)
+    case error(message: String)
+
+    enum CodingKeys: String, CodingKey {
+        case kind
+        case value, unit, amount, currency, date, days, description, message, span
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let kind = try container.decode(String.self, forKey: .kind)
+
+        switch kind {
+        case "Number":
+            let value = try container.decode(Double.self, forKey: .value)
+            self = .number(value: value)
+        case "UnitValue":
+            let value = try container.decode(Double.self, forKey: .value)
+            let unit = try container.decode(String.self, forKey: .unit)
+            self = .unitValue(value: value, unit: unit)
+        case "CurrencyValue":
+            let amount = try container.decode(Double.self, forKey: .amount)
+            let currency = try container.decode(String.self, forKey: .currency)
+            self = .currencyValue(amount: amount, currency: currency)
+        case "DateTime":
+            let date = try container.decode(String.self, forKey: .date)
+            self = .dateTime(date: date)
+        case "TimeDelta":
+            let days = try container.decode(Int64.self, forKey: .days)
+            let desc = try container.decode(String.self, forKey: .description)
+            self = .timeDelta(days: days, description: desc)
+        case "Boolean":
+            let value = try container.decode(Bool.self, forKey: .value)
+            self = .boolean(value: value)
+        case "Error":
+            let message = try container.decode(String.self, forKey: .message)
+            self = .error(message: message)
+        default:
+            self = .error(message: "Unknown result kind: \(kind)")
+        }
+    }
+
+    /// Whether this value represents an error from the Rust engine.
+    var isError: Bool {
+        if case .error = self { return true }
+        return false
+    }
+}

calcpad-macos/Sources/CalcPad/Engine/RustCalculationEngine.swift

@@ -0,0 +1,92 @@
+import CCalcPadEngine
+import Foundation
+
+/// Calculation engine backed by the Rust CalcPad engine via C FFI.
+///
+/// Thread safety: Each call creates its own `EvalContext` on the Rust side,
+/// so concurrent calls from different threads are safe. The C FFI functions
+/// are documented as safe to call from any thread.
+final class RustCalculationEngine: CalculationEngine, @unchecked Sendable {
+
+    private let decoder = JSONDecoder()
+
+    func evaluateLine(_ line: String) -> LineResult {
+        evaluateSingleLine(line, lineNumber: 1)
+    }
+
+    func evaluateSheet(_ text: String) -> [LineResult] {
+        let lines = text.components(separatedBy: "\n")
+
+        // Build C string array for the FFI call
+        let cStrings = lines.map { strdup($0) }
+        defer { cStrings.forEach { free($0) } }
+
+        var pointers = cStrings.map { UnsafePointer<CChar>($0) }
+
+        let resultPtr = pointers.withUnsafeMutableBufferPointer { buffer -> UnsafeMutablePointer<CChar>? in
+            calcpad_eval_sheet(buffer.baseAddress, Int32(lines.count))
+        }
+
+        guard let resultPtr else {
+            return lines.enumerated().map { index, line in
+                LineResult(id: index + 1, expression: line, result: "Error", isError: true)
+            }
+        }
+        defer { calcpad_free_result(resultPtr) }
+
+        let jsonString = String(cString: resultPtr)
+
+        guard let jsonData = jsonString.data(using: .utf8),
+              let response = try? decoder.decode(FFISheetResponse.self, from: jsonData) else {
+            return lines.enumerated().map { index, line in
+                LineResult(id: index + 1, expression: line, result: "Error", isError: true)
+            }
+        }
+
+        return response.results.enumerated().map { index, calcResult in
+            mapToLineResult(calcResult, expression: lines[index], lineNumber: index + 1)
+        }
+    }
+
+    // MARK: - Private
+
+    private func evaluateSingleLine(_ line: String, lineNumber: Int) -> LineResult {
+        let resultPtr = calcpad_eval_line(line)
+
+        guard let resultPtr else {
+            return LineResult(id: lineNumber, expression: line, result: "Error", isError: true)
+        }
+        defer { calcpad_free_result(resultPtr) }
+
+        let jsonString = String(cString: resultPtr)
+
+        guard let jsonData = jsonString.data(using: .utf8),
+              let response = try? decoder.decode(FFIResponse.self, from: jsonData) else {
+            return LineResult(id: lineNumber, expression: line, result: "Error", isError: true)
+        }
+
+        return mapToLineResult(response.result, expression: line, lineNumber: lineNumber)
+    }
+
+    private func mapToLineResult(_ calcResult: FFICalcResult, expression: String, lineNumber: Int) -> LineResult {
+        switch calcResult.value {
+        case .error(let message):
+            // Blank/comment lines produce "empty expression" errors in the Rust engine.
+            // Map these to nil result (matching the protocol's convention for non-evaluable lines).
+            if isEmptyExpressionError(message) {
+                return LineResult(id: lineNumber, expression: expression, result: nil, isError: false)
+            }
+            return LineResult(id: lineNumber, expression: expression, result: "Error: \(message)", isError: true)
+
+        default:
+            return LineResult(id: lineNumber, expression: expression, result: calcResult.metadata.display, isError: false)
+        }
+    }
+
+    /// The Rust engine returns an error for blank lines, comments, and other
+    /// non-evaluable input. We detect these to return nil (matching protocol convention).
+    private func isEmptyExpressionError(_ message: String) -> Bool {
+        let lower = message.lowercased()
+        return lower.contains("empty") || lower.contains("no expression") || lower.contains("comment")
+    }
+}