Run more ordinary Fe at compile time

[micahscopes]

This lets compile-time evaluation run more ordinary Fe, so a helper does not need a separate const-only version.

• A const fn can update a local through a mut borrow

  const fn set(value: mut u8) { value = 42 }
  
  const fn answer() -> u8 {
      let mut x: u8 = 0
      set(value: mut x)
      x
  }
  

  answer() now evaluates to 42; on master, evaluation rejects the borrow with InvalidProviderUse. Borrows through pointers or of provider-backed locals still fail, since compile-time evaluation has no memory outside its own call frames. Evaluation also fails if a function returns a borrow of its own local.

• A const fn can take an immutable trait provider with uses, and a caller can supply one with with

  const fn consume<T>() -> T uses (evidence: Compute<Item = T>) {
      evidence.compute()
  }
  
  const fn answer() -> u256 {
      with (Compute<Item = u256> = Number { value: 11 }) { consume<u256>() }
  }
  

  On master, the uses clause and the with are both errors. A test runs the same code at compile time and at runtime and checks that the results agree.

• Rebuild the compiler when a file is added to core or std. Before, a new library file did not trigger a rebuild, so a cached build kept the old library. The fingerprint only invalidates caches and is never compared, so its per-platform value is harmless.

A few decisions:

• Providers are passed as values, matched to the callee's effect by binding rather than by argument position
• Mutable providers, storage effects, and extern functions with effects remain rejected
• The error for with in a const fn (8-0056) is removed, so that code is no longer emitted. The two remaining errors for effects in a const fn (8-0055, 8-0063) now say which effects are supported

How this fits mainline:

• Fix CTFE evaluation of symbolic array repeats #1556 made constant evaluation transactional: an evaluation that needs a value still given by a generic parameter stops, is thrown away, and is rerun once the parameter is known. Both features fit that design without changes to it. A borrow points into the evaluator's own call frames, which are thrown away with the evaluation. A call with providers stops and reruns like any other call, and a test checks that it evaluates with its provider once the parameter is known. Extraction of symbolic terms already skips calls with providers, so a provider never ends up in a stored term. Fix CTFE evaluation of symbolic array repeats #1556 had kept the borrow restriction on purpose, with a test pinning it; that test now checks that the borrowed read evaluates, and the "Borrowing scope" paragraph of docs/ctfe-deferral-audit.md is updated.
• Preserve effect provider identity across repeated calls #1564 evaluates a with provider such as Number { value: 11 } once per with entry and may pass it by place. Const evaluation reads a provider passed by place from that place.
• Keep integer width for view-typed values in constant evaluation #1594 makes the integer width lookup in consts.rs see through view types. This PR does not change that code, and Keep integer width for view-typed values in constant evaluation #1594's ctfe_view_int_bitnot.fe passes.

Overlap with open PRs: #1576 conflicts in const_check.rs and machine.rs. It moves the const fn effects check, which this PR changes from "any effects" to const_effects_supported, so whichever lands second carries that change into the moved check. #1455 and #1506 conflict in const_check.rs as well. Other open PRs that touch these files conflict only where they already conflict with master.

Planned later PRs in this series (trait evidence, named implementation selection, generated code) build on the provider support here.