Replace :! binding syntax with phase keywords and contextual defaults (#7479)

Implement the toolchain side of proposal #7254, removing the `:!`
binding
syntax for generic and template parameters in favor of the keywords
`generic`,
`template`, and `runtime` plus contextual defaults for phase.

For valid programs this is semantics-preserving: each binding resolves
to the
same phase, and produces the same SemIR, as it did under `:!`/`:`. The
parser
derives a binding's phase from its syntactic context plus any explicit
phase
keyword; new diagnostics and error recovery for misused keywords are
described
below.

Implementation details for each component:

- Lexer: remove the `:!` (`ColonExclaim`) token, move its virtual
parse-node
  budget onto `:`, and add the `generic` and `runtime` keywords.
- Parser: thread a `BindingContext` (`ExplicitParam`, `DeducedParam`, or
`CompileTimeEntityParam`) from declaration introducers down through
parameter
lists to each binding pattern, using a one-token lookahead to
distinguish a
name-qualifier parameter list from a declaration's own final list.
Parameters
of a compile-time entity (`class`, `interface`, `constraint`, `choice`,
`alias`, `export`, `namespace`) and deduced `[]` parameters default to
checked
generic; explicit function parameters and local bindings default to
runtime.
`HandleBindingPattern` resolves the phase from that context plus the
keyword: a
`generic` keyword needs no node of its own (the phase is carried by the
  binding's node kind), while a `runtime` keyword is preserved as a
`RuntimeBindingName` node so `check` can name it in a diagnostic. A
phase
keyword that is merely redundant with the contextual default is
diagnosed
  here, without invalidating the parse tree.
- Check: a phase keyword that is invalid for its context (for example
`runtime`
on a checked-generic parameter) is diagnosed here, and recovers by
building an
error binding that still introduces the name so that later uses of it do
not
  produce cascading errors.

The removed `:!` syntax is now rejected as an ordinary parse error.

The `form`/`:?`/`->?` ("extended types") portion of proposal #7254 is
left for a
separate change.

Assisted-by: Claude Code

examples/advent2024/day1_common.carbon

@@ -12,7 +12,7 @@ import library "io_utils";
 
 // Read a sequence of lines each containing a pair of numbers into two arrays.
 // Returns the number of lines read.
-fn ReadInputs[N:! Core.IntLiteral](ref a: array(i32, N), ref b: array(i32, N)) -> i32 {
+fn ReadInputs[N: Core.IntLiteral](ref a: array(i32, N), ref b: array(i32, N)) -> i32 {
   for (i: i32 in Core.Range(N)) {
     var av: i32;
     var bv: i32;

examples/advent2024/io_utils.carbon

@@ -27,13 +27,13 @@ fn CharOrEOF.EOF() -> Self {
   return (-1 as i32) as CharOrEOF;
 }
 
-impl forall [U:! Core.ImplicitAs(char)] U as Core.ImplicitAs(CharOrEOF) {
+impl forall [U: Core.ImplicitAs(char)] U as Core.ImplicitAs(CharOrEOF) {
   fn Convert(self: char) -> CharOrEOF {
     return ((self as u8) as i32) as CharOrEOF;
   }
 }
 
-impl forall [U:! Core.ImplicitAs(CharOrEOF)]
+impl forall [U: Core.ImplicitAs(CharOrEOF)]
     CharOrEOF as Core.EqWith(U) {
   fn Equal(self, other: CharOrEOF) -> bool {
     return (self as i32) == (other as i32);
@@ -43,7 +43,7 @@ impl forall [U:! Core.ImplicitAs(CharOrEOF)]
   }
 }
 
-impl forall [U:! Core.ImplicitAs(CharOrEOF)]
+impl forall [U: Core.ImplicitAs(CharOrEOF)]
     CharOrEOF as Core.OrderedWith(U) {
   fn Less(self, other: CharOrEOF) -> bool {
     return (self as i32) < (other as i32);
@@ -59,7 +59,7 @@ impl forall [U:! Core.ImplicitAs(CharOrEOF)]
   }
 }
 
-impl forall [U:! Core.ImplicitAs(char)]
+impl forall [U: Core.ImplicitAs(char)]
     CharOrEOF as Core.SubWith(U) where .Result = i32 {
   fn Op(self, other: char) -> i32 {
     return (self as i32) - ((other as u8) as i32);
@@ -105,7 +105,7 @@ fn ConsumeChar(c: char) -> bool {
   return true;
 }
 
-fn ReadInt[N:! Core.IntLiteral](ref p: Core.Int(N)) -> bool {
+fn ReadInt[N: Core.IntLiteral](ref p: Core.Int(N)) -> bool {
   var read_any_digits: bool = false;
   let negative: bool = ConsumeChar('-');
   // TODO: `p = 0;` crashes the toolchain, see
@@ -133,7 +133,7 @@ fn ReadInt[N:! Core.IntLiteral](ref p: Core.Int(N)) -> bool {
   return read_any_digits;
 }
 
-fn PrintIntNoNewline[N:! Core.IntLiteral](n_val: Core.Int(N)) {
+fn PrintIntNoNewline[N: Core.IntLiteral](n_val: Core.Int(N)) {
   // TODO: var pow10: Core.Int(N) = 1; crashes the toolchain.
   var pow10: Core.Int(N) = (1 as i32) as Core.Int(N);
   var n: Core.Int(N) = n_val;
@@ -152,7 +152,7 @@ fn PrintIntNoNewline[N:! Core.IntLiteral](n_val: Core.Int(N)) {
   }
 }
 
-fn PrintInt[N:! Core.IntLiteral](n_val: Core.Int(N)) {
+fn PrintInt[N: Core.IntLiteral](n_val: Core.Int(N)) {
   PrintIntNoNewline(n_val);
   Core.PrintChar('\n');
 }

examples/advent2024/sort.carbon

@@ -19,14 +19,14 @@ impl i32 as Ordered {
   fn GreaterOrEquivalent(self, other: Self) -> bool { return self >= other; }
 }
 
-fn Swap[T:! Core.Copy & Core.Destroy](ref from: T, ref to: T) {
+fn Swap[T: Core.Copy & Core.Destroy](ref from: T, ref to: T) {
   var tmp: T = from;
   from = to;
   to = tmp;
 }
 
 fn Partition
-    [T:! Core.Copy & Core.Destroy & Ordered, N:! Core.IntLiteral]
+    [T: Core.Copy & Core.Destroy & Ordered, N: Core.IntLiteral]
     (ref a: array(T, N), from_in: i32, to_in: i32) -> i32 {
   var pivot_index: i32 = from_in;
   let pivot: T = a[pivot_index];
@@ -52,7 +52,7 @@ fn Partition
 }
 
 fn Quicksort
-    [T:! Core.Copy & Core.Destroy & Ordered, N:! Core.IntLiteral]
+    [T: Core.Copy & Core.Destroy & Ordered, N: Core.IntLiteral]
     (ref a: array(T, N), from: i32, to: i32) {
   if (from + 1 >= to) { return; }
   var pivot: i32 = Partition(ref a, from, to);