refactor: deduplicate utility helpers across the codebase (#23338)

Audited exported helpers in `coderd/util/*`, `testutil`, `cryptorand`,
and friends, then replaced duplicated implementations with canonical
versions.

- **fix: `maps.SortedKeys` generic signature** — value type was
hardcoded to `any`, making it impossible to actually call. Added second
type parameter `V any`. Added table-driven tests with `cmp.Diff`.
- **refactor: replace ad-hoc ptr helpers with `ptr.Ref`** — removed
`int64Ptr`, `stringPtr`, `boolPtr`, `i64ptr`, `strPtr`, `PtrInt32`
across 6 files.
- **refactor: replace local `sortedKeys`/`sortKeys` with
`maps.SortedKeys`** — now that the signature is fixed, scripts can use
it.
- **refactor: replace hand-rolled `capitalize` with
`strings.Capitalize`** — the typegen version was also not UTF-8 safe.

> 🤖 This PR was created with the help of Coder Agents, and was reviewed
by my human. 🧑‍💻

coderd/chatd/chatd.go

@@ -30,6 +30,7 @@ import (
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
 	"github.com/coder/coder/v2/coderd/database/pubsub"
 	coderdpubsub "github.com/coder/coder/v2/coderd/pubsub"
+	"github.com/coder/coder/v2/coderd/util/ptr"
 	"github.com/coder/coder/v2/coderd/webpush"
 	"github.com/coder/coder/v2/coderd/workspacestats"
 	"github.com/coder/coder/v2/codersdk"
@@ -2916,19 +2917,19 @@ func (p *Server) runChat(
 		var usageForCost codersdk.ChatMessageUsage
 		if hasUsage {
 			if step.Usage.InputTokens != 0 {
-				usageForCost.InputTokens = int64Ptr(step.Usage.InputTokens)
+				usageForCost.InputTokens = ptr.Ref(step.Usage.InputTokens)
 			}
 			if step.Usage.OutputTokens != 0 {
-				usageForCost.OutputTokens = int64Ptr(step.Usage.OutputTokens)
+				usageForCost.OutputTokens = ptr.Ref(step.Usage.OutputTokens)
 			}
 			if step.Usage.ReasoningTokens != 0 {
-				usageForCost.ReasoningTokens = int64Ptr(step.Usage.ReasoningTokens)
+				usageForCost.ReasoningTokens = ptr.Ref(step.Usage.ReasoningTokens)
 			}
 			if step.Usage.CacheCreationTokens != 0 {
-				usageForCost.CacheCreationTokens = int64Ptr(step.Usage.CacheCreationTokens)
+				usageForCost.CacheCreationTokens = ptr.Ref(step.Usage.CacheCreationTokens)
 			}
 			if step.Usage.CacheReadTokens != 0 {
-				usageForCost.CacheReadTokens = int64Ptr(step.Usage.CacheReadTokens)
+				usageForCost.CacheReadTokens = ptr.Ref(step.Usage.CacheReadTokens)
 			}
 		}
 		totalCostMicros := chatcost.CalculateTotalCostMicros(usageForCost, callConfig.Cost)
@@ -3532,10 +3533,6 @@ func (p *Server) resolveModelConfig(
 	return defaultConfig, nil
 }
 
-func int64Ptr(value int64) *int64 {
-	return &value
-}
-
 func refreshChatWorkspaceSnapshot(
 	ctx context.Context,
 	chat database.Chat,

coderd/chatd/chatprovider/chatprovider_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/v2/coderd/chatd/chatprovider"
+	"github.com/coder/coder/v2/coderd/util/ptr"
 	"github.com/coder/coder/v2/codersdk"
 )
 
@@ -25,37 +26,37 @@ func TestReasoningEffortFromChat(t *testing.T) {
 		{
 			name:     "OpenAICaseInsensitive",
 			provider: "openai",
-			input:    stringPtr(" HIGH "),
-			want:     stringPtr(string(fantasyopenai.ReasoningEffortHigh)),
+			input:    ptr.Ref(" HIGH "),
+			want:     ptr.Ref(string(fantasyopenai.ReasoningEffortHigh)),
 		},
 		{
 			name:     "AnthropicEffort",
 			provider: "anthropic",
-			input:    stringPtr("max"),
-			want:     stringPtr(string(fantasyanthropic.EffortMax)),
+			input:    ptr.Ref("max"),
+			want:     ptr.Ref(string(fantasyanthropic.EffortMax)),
 		},
 		{
 			name:     "OpenRouterEffort",
 			provider: "openrouter",
-			input:    stringPtr("medium"),
-			want:     stringPtr(string(fantasyopenrouter.ReasoningEffortMedium)),
+			input:    ptr.Ref("medium"),
+			want:     ptr.Ref(string(fantasyopenrouter.ReasoningEffortMedium)),
 		},
 		{
 			name:     "VercelEffort",
 			provider: "vercel",
-			input:    stringPtr("xhigh"),
-			want:     stringPtr(string(fantasyvercel.ReasoningEffortXHigh)),
+			input:    ptr.Ref("xhigh"),
+			want:     ptr.Ref(string(fantasyvercel.ReasoningEffortXHigh)),
 		},
 		{
 			name:     "InvalidEffortReturnsNil",
 			provider: "openai",
-			input:    stringPtr("unknown"),
+			input:    ptr.Ref("unknown"),
 			want:     nil,
 		},
 		{
 			name:     "UnsupportedProviderReturnsNil",
 			provider: "bedrock",
-			input:    stringPtr("high"),
+			input:    ptr.Ref("high"),
 			want:     nil,
 		},
 		{
@@ -83,7 +84,7 @@ func TestMergeMissingProviderOptions_OpenRouterNested(t *testing.T) {
 	options := &codersdk.ChatModelProviderOptions{
 		OpenRouter: &codersdk.ChatModelOpenRouterProviderOptions{
 			Reasoning: &codersdk.ChatModelReasoningOptions{
-				Enabled: boolPtr(true),
+				Enabled: ptr.Ref(true),
 			},
 			Provider: &codersdk.ChatModelOpenRouterProvider{
 				Order: []string{"openai"},
@@ -93,21 +94,21 @@ func TestMergeMissingProviderOptions_OpenRouterNested(t *testing.T) {
 	defaults := &codersdk.ChatModelProviderOptions{
 		OpenRouter: &codersdk.ChatModelOpenRouterProviderOptions{
 			Reasoning: &codersdk.ChatModelReasoningOptions{
-				Enabled:   boolPtr(false),
-				Exclude:   boolPtr(true),
-				MaxTokens: int64Ptr(123),
-				Effort:    stringPtr("high"),
+				Enabled:   ptr.Ref(false),
+				Exclude:   ptr.Ref(true),
+				MaxTokens: ptr.Ref[int64](123),
+				Effort:    ptr.Ref("high"),
 			},
-			IncludeUsage: boolPtr(true),
+			IncludeUsage: ptr.Ref(true),
 			Provider: &codersdk.ChatModelOpenRouterProvider{
 				Order:             []string{"anthropic"},
-				AllowFallbacks:    boolPtr(true),
-				RequireParameters: boolPtr(false),
-				DataCollection:    stringPtr("allow"),
+				AllowFallbacks:    ptr.Ref(true),
+				RequireParameters: ptr.Ref(false),
+				DataCollection:    ptr.Ref("allow"),
 				Only:              []string{"openai"},
 				Ignore:            []string{"foo"},
 				Quantizations:     []string{"int8"},
-				Sort:              stringPtr("latency"),
+				Sort:              ptr.Ref("latency"),
 			},
 		},
 	}
@@ -136,15 +137,3 @@ func TestMergeMissingProviderOptions_OpenRouterNested(t *testing.T) {
 	require.Equal(t, []string{"int8"}, options.OpenRouter.Provider.Quantizations)
 	require.Equal(t, "latency", *options.OpenRouter.Provider.Sort)
 }
-
-func stringPtr(value string) *string {
-	return &value
-}
-
-func boolPtr(value bool) *bool {
-	return &value
-}
-
-func int64Ptr(value int64) *int64 {
-	return &value
-}