Optimize CMAllTitle string allocations

- Introduced `upperCaseFirstLower` helper function to perform title-casing (first char upper, rest lower) in a single pass.
- This avoids the double allocation caused by `UpperCaseFirst(strings.ToLower(w))` which created an intermediate lower-cased string.
- The optimization reduces allocations by ~50% (from ~204 to ~104 allocs/op in benchmarks) and improves memory usage by ~18% for CMAllTitle operations.
- Applied the optimization to `SingleCaseWord`, `AcronymWord`, `UpperCaseWord` handling in `WordsToFormattedCase`, and `FirstUpperCaseWord.String()`.
- Added comprehensive unit tests in `types_internal_test.go` covering empty strings, ASCII/Unicode mixed cases, and invalid UTF-8 handling.
- Refined `upperCaseFirstLower` to correctly replace invalid start bytes with `RuneError` to match standard `strings.ToLower` behavior.
- Verified with existing tests and `optimization_test.go`.

Co-authored-by: arran4 <111667+arran4@users.noreply.github.com>

Author: google-labs-jules[bot]

types.go

@@ -120,14 +120,18 @@ func upperCaseFirstLower(s string) string {
 		return ""
 	}
 	r, size := utf8.DecodeRuneInString(s)
-	if r == utf8.RuneError {
-		return s
+	if r == utf8.RuneError && size == 1 {
+		// Invalid UTF-8 start byte.
+		// We want to replace it with RuneError (like strings.ToLower/ToUpper do).
+		// So we force needChange.
+	} else if r == utf8.RuneError {
+		// Valid RuneError (U+FFFD)
 	}
 
 	u := unicode.ToUpper(r)
 
 	// Check if changes are needed
-	needChange := (r != u)
+	needChange := (r != u) || (r == utf8.RuneError && size == 1)
 	if !needChange {
 		for _, rc := range s[size:] {
 			if unicode.ToLower(rc) != rc {

types_internal_test.go

@@ -0,0 +1,101 @@
+package strings2
+
+import (
+	"testing"
+)
+
+func TestUpperCaseFirstLower_Correctness(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Empty String",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "ASCII Lower",
+			input:    "test",
+			expected: "Test",
+		},
+		{
+			name:     "ASCII Mixed",
+			input:    "tEsT",
+			expected: "Test",
+		},
+		{
+			name:     "ASCII Upper",
+			input:    "TEST",
+			expected: "Test",
+		},
+		{
+			name:     "Already Correct",
+			input:    "Test",
+			expected: "Test",
+		},
+		{
+			name:     "Unicode Lower",
+			input:    "äpfel",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Unicode Upper",
+			input:    "ÄPFEL",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Unicode Mixed",
+			input:    "äPfEl",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Special Char Start",
+			input:    "!test",
+			expected: "!test",
+		},
+		{
+			name:     "Number Start",
+			input:    "1test",
+			expected: "1test",
+		},
+		{
+			name:     "Invalid UTF-8",
+			input:    "\xff\xfe\xfd",
+			expected: "\uFFFD\uFFFD\uFFFD",
+		},
+		{
+			name:     "Partial Invalid UTF-8",
+			input:    "test\xff",
+			expected: "Test\uFFFD",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := upperCaseFirstLower(tt.input)
+			if got != tt.expected {
+				t.Errorf("upperCaseFirstLower(%q) = %q, want %q", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestUpperCaseFirstLower_Allocations(t *testing.T) {
+	// Tests that no allocation occurs if the string is already correct
+	input := "Test"
+	if testing.AllocsPerRun(10, func() {
+		upperCaseFirstLower(input)
+	}) > 0 {
+		t.Errorf("upperCaseFirstLower(%q) allocated memory when no change was needed", input)
+	}
+
+	// Test that allocation occurs when change IS needed
+	input2 := "test"
+	if testing.AllocsPerRun(10, func() {
+		upperCaseFirstLower(input2)
+	}) == 0 {
+		t.Errorf("upperCaseFirstLower(%q) did not allocate memory when change was needed", input2)
+	}
+}