Add const where predicates

[micahscopes]

This lets an item state a boolean condition in its where clause, such as N > 0, and have the compiler check it wherever the item is used.

• A where clause can hold boolean conditions next to trait bounds

  const fn bounded<const N: usize>() -> u256 where N > 0 { 42 }
  

  bounded<1>() is accepted and bounded<0>() is rejected, even though the body never reads N. On master, a where clause takes only trait bounds, so where N > 0 is a parse error.

• A generic caller satisfies a condition by stating the same one

  const fn forward<const COUNT: usize>() -> u256 where COUNT > 0 { bounded<COUNT>() }
  

  The same holds in anonymous constants of the caller's signature and body, such as an array length.

• Structs, enums and inherent methods take conditions too

  struct Bounded<const N: usize> where N > 0 { value: u256 }
  

  Every use of Bounded<0> is rejected, including unused type annotations, defaults and aliases. For a constrained enum, unit variants such as Choice<0>::Empty are rejected too. Method conditions are checked on the method that ordinary resolution picks.

• A condition without generic parameters is checked where it is declared, even if nothing uses the item

  fn unused() where false {}
  

• A condition that needs several lines can be written as a block

  fn bounded<const N: usize>() where {
      let limit: usize = 8
      N < limit
  } {}
  

• where T without : now parses as a condition, and type checking reports the missing trait bound. On master it is a parse error.

• A tuple-variant constructor used as a value, such as let f = Choice::Value, is an error. On master it panics during lowering.

• #[error] lowering errors get code prefix 13. On master they share prefix 16 with borrow-checking errors, so error[16-0003] can name two different errors.

A few decisions:

• Forwarding is exact, not implication: after substitution the two conditions must be the same resolved expression, so N > 1 does not establish N > 0
• A concrete condition is evaluated at compile time, and a failed evaluation is an error, never a pass
• Conditions never select impls or methods and add no solver assumptions
• A braced condition is read as a condition only when a ,, another predicate or the item's own { follows it, so where T: Copy, { body } keeps its meaning. In trait and extern function declarations, a block right after where is always a condition
• Compile-time evaluation refuses a body that has an unmet requirement

Limits:

• Conditions in traits, on trait impls with generic parameters, on generic impl blocks themselves and on items nested in generic items are rejected with an error that says so
• Only literals, const paths, unary and binary operations, casts and calls to const functions can be forwarded. Blocks, control flow and other expressions need concrete arguments
• A constrained struct or enum must be fully applied; it cannot pass through a higher-kinded parameter
• Predicate blocks are borrow checked like other const bodies. The test for this needs frame-local borrows in const evaluation (Run more ordinary Fe at compile time #1582), so it will land with that PR
• The tree-sitter grammar reads where T: Copy, { body } as a condition without a body, since it cannot look past the block; the compiler's parser is unaffected

Also included:

• Explicit const arguments of method and associated function calls, such as Window<1> {}.take<3>(), are evaluated against the parameter's type, as a free function's are. On master, compile-time evaluation of such a function panics when it reads that parameter. It is its own commit, with a test.
• A fix for a flaky race between parallel trybuild tests.
• fe fmt and the tree-sitter grammar understand the new syntax.

Recent mainline changes:

• Predicates read Fix CTFE evaluation of symbolic array repeats #1556's evaluation results the way static_assert does. An evaluation that fails or still waits on an unknown value is an error.
• An unmet requirement in a type is error[3-0057], since Fix CTFE evaluation of symbolic array repeats #1556 took codes 50 to 56.
• The other recent merges, including Lower native raw memory copies through memmove #1579, Add explicitly owned native byte buffers #1580, Fix signature hashing for long error and event names #1592 and Keep integer width for view-typed values in constant evaluation #1594, need no changes here.

Overlap with open PRs (git merge-tree against their current heads, compared with master): this PR adds conflicts with #1535 in ty_check/callable.rs, in the loop that evaluates explicit const arguments, and in ty_check/env.rs; with #1582 in const_check.rs, where it changes the effects condition that this PR moves; and with draft #1536 in instance/template.rs. #1535 already conflicts with master in capability/index.rs, capability/shape.rs and const_ty.rs, and #1582 in ctfe/machine.rs. Other open PRs, including #1589, get no new conflicts.

Const predicates on trait impls would build on this requirement checking.