perf(core): optimize isPrime with 6k±1 algorithm and add benchmarks (#5)

Optimize isPrime function using the 6k±1 optimization, which reduces
iterations by ~33% since all primes > 3 are of the form 6k±1.

Changes:
- Use 6k±1 pattern for trial division instead of checking all odd numbers
- Add early exit for divisibility by 3
- Add comprehensive benchmark covering edge cases, project primes,
  and worst-case scenarios

All cases maintain zero allocations.

Author: jkyberneees

core/params.go

@@ -96,20 +96,22 @@ func ValidateParams(params kmosaic.MOSAICParams) error {
 	return nil
 }
 
-// isPrime checks if a number is prime using a simple trial division.
+// isPrime checks if a number is prime using optimized trial division.
+// Uses the 6k±1 optimization since all primes > 3 are of the form 6k±1.
 // This is used for validating parameters, not for generating large primes.
 func isPrime(n int) bool {
 	if n < 2 {
 		return false
 	}
-	if n == 2 {
+	if n == 2 || n == 3 {
 		return true
 	}
-	if n%2 == 0 {
+	if n%2 == 0 || n%3 == 0 {
 		return false
 	}
-	for i := 3; i*i <= n; i += 2 {
-		if n%i == 0 {
+	// Check divisibility by numbers of the form 6k±1
+	for i := 5; i*i <= n; i += 6 {
+		if n%i == 0 || n%(i+2) == 0 {
 			return false
 		}
 	}

core/params_test.go

@@ -91,3 +91,52 @@ func TestIsPrime(t *testing.T) {
 		}
 	}
 }
+
+func BenchmarkIsPrime(b *testing.B) {
+	testCases := []struct {
+		name string
+		n    int
+	}{
+		// Edge cases
+		{"Edge_Zero", 0},
+		{"Edge_One", 1},
+		{"Edge_Two", 2},
+		{"Edge_Three", 3},
+
+		// Small numbers
+		{"Small_Prime", 17},
+		{"Small_Composite_Even", 18},
+		{"Small_Composite_Odd", 21},     // 3*7
+		{"Small_Composite_ByThree", 27}, // 3^3
+
+		// Actual project primes (from MOS128/256 params)
+		{"Project_EGRW128_Prime", 1021},
+		{"Project_EGRW256_Prime", 2039},
+		{"Project_TDD_Prime", 7681},
+		{"Project_SLSS_Prime", 12289},
+
+		// Composites near project primes (harder cases)
+		{"Near_1021_Composite", 1023},   // 3*11*31
+		{"Near_2039_Composite", 2041},   // 13*157
+		{"Near_7681_Composite", 7685},   // 5*29*53
+		{"Near_12289_Composite", 12291}, // 3*4097
+
+		// Large primes (worst case - need many checks)
+		{"Large_Prime_Near_Square", 104729}, // sqrt ≈ 323
+		{"Large_Prime_100k", 104743},
+		{"Very_Large_Prime", 1000003},
+
+		// Large composites (various patterns)
+		{"Large_Composite_Even", 104730},
+		{"Large_Composite_Odd", 104731},      // 181*579
+		{"Large_Composite_Product", 1000001}, // 101*9901
+	}
+
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				isPrime(tc.n)
+			}
+		})
+	}
+}