refactor: Extract magic numbers and use switch statements

Code quality improvements based on code review:

- Add SpeedLimit enum with named constants for intervals and CPS limits
  - minInterval (0.01s = 100 CPS)
  - maxInterval (300s = 1 click per 5 min)
  - safeGuardInterval (0.001s to prevent division by zero)

- Add SpeedThreshold enum with named constants for speed tiers
  - CPS thresholds for formatting (high/medium/low)
  - CPS thresholds for descriptions (veryFast/fast/normal)
  - Interval thresholds for slow speeds (slow/verySlow)

- Refactor formatClickSpeed() to use switch statement
  - Replace if/else chain with pattern matching
  - More idiomatic Swift code

- Refactor describeClickSpeed() to use nested switch statements
  - Primary switch on CPS for fast speeds
  - Secondary switch on interval for slow speeds
  - Eliminates all magic numbers

Benefits:
- Self-documenting code with clear intent
- Easier to maintain and adjust thresholds
- More idiomatic Swift patterns
- Better readability

Author: claude

Sources/ClickIt/Lite/SimplifiedMainView.swift

@@ -9,6 +9,34 @@ import SwiftUI
 
 struct SimplifiedMainView: View {
 
+    // MARK: - Speed Configuration
+
+    /// Speed limits for click intervals
+    private enum SpeedLimit {
+        static let minInterval: Double = 0.01   // 100 CPS
+        static let maxInterval: Double = 300.0  // 1 click per 5 min
+        static var minCPS: Double { 1.0 / maxInterval }
+        static var maxCPS: Double { 1.0 / minInterval }
+        static let safeGuardInterval: Double = 0.001 // Prevents division by zero
+    }
+
+    /// Thresholds for speed descriptions and formatting
+    private enum SpeedThreshold {
+        // CPS thresholds for formatting
+        static let highCPS: Double = 10.0
+        static let mediumCPS: Double = 1.0
+        static let lowCPS: Double = 0.1
+
+        // CPS thresholds for descriptions
+        static let veryFastCPS: Double = 50.0
+        static let fastCPS: Double = 10.0
+        static let normalCPS: Double = 1.0
+
+        // Interval thresholds for descriptions (seconds)
+        static let slowInterval: Double = 60.0
+        static let verySlowInterval: Double = 120.0
+    }
+
     // MARK: - Properties
 
     @StateObject private var viewModel = SimpleViewModel()
@@ -178,18 +206,18 @@ struct SimplifiedMainView: View {
                 value: Binding(
                     get: {
                         // Convert interval to log(CPS)
-                        let cps = 1.0 / max(viewModel.clickInterval, 0.001)
+                        let cps = 1.0 / max(viewModel.clickInterval, SpeedLimit.safeGuardInterval)
                         return log10(cps)
                     },
                     set: { logCPS in
                         // Convert log(CPS) back to interval
                         let cps = pow(10.0, logCPS)
                         let interval = 1.0 / cps
-                        // Clamp to valid range (0.01s to 300s)
-                        viewModel.clickInterval = min(max(interval, 0.01), 300.0)
+                        // Clamp to valid range
+                        viewModel.clickInterval = min(max(interval, SpeedLimit.minInterval), SpeedLimit.maxInterval)
                     }
                 ),
-                in: log10(1.0/300.0)...log10(100.0) // log(0.00333) to log(100)
+                in: log10(SpeedLimit.minCPS)...log10(SpeedLimit.maxCPS)
             )
             .disabled(viewModel.isRunning)
 
@@ -217,35 +245,49 @@ struct SimplifiedMainView: View {
     /// Format click speed for display
     private func formatClickSpeed(interval: Double) -> String {
         let cps = 1.0 / interval
-
-        if cps >= 10 {
-            return String(format: "%.0f CPS", cps)
-        } else if cps >= 1 {
-            return String(format: "%.1f CPS", cps)
-        } else if cps >= 0.1 {
-            return String(format: "%.2f CPS", cps)
-        } else {
-            return String(format: "%.3f CPS", cps)
+        let format: String
+
+        switch cps {
+        case SpeedThreshold.highCPS...:
+            format = "%.0f CPS"
+        case SpeedThreshold.mediumCPS..<SpeedThreshold.highCPS:
+            format = "%.1f CPS"
+        case SpeedThreshold.lowCPS..<SpeedThreshold.mediumCPS:
+            format = "%.2f CPS"
+        default:
+            format = "%.3f CPS"
         }
+
+        return String(format: format, cps)
     }
 
     /// Describe click speed in human-readable terms
     private func describeClickSpeed(interval: Double) -> String {
         let cps = 1.0 / interval
 
-        if cps >= 50 {
+        switch cps {
+        case SpeedThreshold.veryFastCPS...:
             return "⚡ Very Fast - \(String(format: "%.1f", interval * 1000))ms per click"
-        } else if cps >= 10 {
+
+        case SpeedThreshold.fastCPS..<SpeedThreshold.veryFastCPS:
             return "🚀 Fast - \(String(format: "%.2f", interval))s per click"
-        } else if cps >= 1 {
+
+        case SpeedThreshold.normalCPS..<SpeedThreshold.fastCPS:
             return "⏱️ Normal - 1 click every \(String(format: "%.1f", interval))s"
-        } else if interval < 60 {
-            return "🐌 Slow - 1 click every \(String(format: "%.1f", interval))s"
-        } else if interval < 120 {
-            return "🐢 Very Slow - 1 click every \(Int(interval))s (~\(Int(interval/60)) min)"
-        } else {
-            let minutes = Int(interval / 60)
-            return "🦥 Ultra Slow - 1 click every \(minutes) minutes"
+
+        default:
+            // For CPS < 1.0, describe by interval instead
+            switch interval {
+            case ..<SpeedThreshold.slowInterval:
+                return "🐌 Slow - 1 click every \(String(format: "%.1f", interval))s"
+
+            case SpeedThreshold.slowInterval..<SpeedThreshold.verySlowInterval:
+                return "🐢 Very Slow - 1 click every \(Int(interval))s (~\(Int(interval/60)) min)"
+
+            default:
+                let minutes = Int(interval / 60)
+                return "🦥 Ultra Slow - 1 click every \(minutes) minutes"
+            }
         }
     }