refactor(formula,spec): name the refusal type parameters so the vocabulary gate does not read them as code constants

`check:dispatcher-error-vocabulary`'s object-literal constant shape matches
`code: K;` in a type literal, so a single-letter type parameter reads as an
unresolvable SCREAMING code constant. `Code` / `Codes` say the same thing
and stay out of that grammar.

Claude-Session: https://claude.ai/code/session_01QcAS3qiYYZNezaxZxaUdMV
Co-Authored-By: Claude <noreply@anthropic.com>

Author: claude

packages/formula/src/expression-refusal.ts

@@ -139,11 +139,11 @@ export type ExpressionRefusalCode = keyof ExpressionRefusalParams;
 
 /**
  * One refusal's `code` and `params`, correlated: narrowing on `code` narrows
- * `params`. `C` restricts it to the codes one producer emits.
+ * `params`. `Codes` restricts it to the codes one producer emits.
  */
-export type ExpressionRefusal<C extends ExpressionRefusalCode = ExpressionRefusalCode> = {
-  [K in C]: { readonly code: K; readonly params: ExpressionRefusalParams[K] };
-}[C];
+export type ExpressionRefusal<Codes extends ExpressionRefusalCode = ExpressionRefusalCode> = {
+  [Code in Codes]: { readonly code: Code; readonly params: ExpressionRefusalParams[Code] };
+}[Codes];
 
 /** The codes `collectCelRootIdentifiers` emits. */
 export type CelRootsRefusalCode = 'empty-expression' | 'cel-parse-failed';

packages/formula/src/validate.ts

@@ -192,9 +192,9 @@ export type ExprValidationError = {
  * between `code` and `params` is asserted; every call site is checked against
  * {@link ExpressionRefusalParams} for its own code.
  */
-function refusal<C extends ExprValidationCode>(
-  code: C,
-  params: ExpressionRefusalParams[C],
+function refusal<Code extends ExprValidationCode>(
+  code: Code,
+  params: ExpressionRefusalParams[Code],
   source: string,
   message: string,
 ): ExprValidationError {

packages/spec/src/automation/flow-node-expression-paths.ts

@@ -494,7 +494,7 @@ export type PredicateSlotRefusalCode = keyof PredicateSlotRefusalParams;
  * `params` — narrowing on `code` narrows `params`.
  */
 export type PredicateSlotRefusal = { message: string; source: string } & {
-  [C in PredicateSlotRefusalCode]: { readonly code: C; readonly params: PredicateSlotRefusalParams[C] };
+  [Code in PredicateSlotRefusalCode]: { readonly code: Code; readonly params: PredicateSlotRefusalParams[Code] };
 }[PredicateSlotRefusalCode];
 
 /**