`Pair2<1 + 1, Int>` is correct CkLang, and the compiler answered it with a
diagnostic about the wrong argument: E0742 on the `Int`, blaming it for the
value parameter `size` that the `1 + 1` beside it had already filled. Nothing
about that is a missing feature. The type-level value expression is a
`GenericValueExpr` node, `TypeRef::from_node` admits it nowhere, so both the
lift and the E0742 walk silently dropped the argument AND left the slot cursor
where it was — every later argument then read against the previous parameter.
Correct code, wrong span, wrong parameter, and no way for the author to act on
it.

The quieter half is worse, because it is a Law 1 breach with no diagnostic at
all: `record B { xs: List<byte, 64 + 0> }` sized as a field with no bound, and
`Slot<PAGE + 1>` checked clean while the compiler held no number for the slot.
A size the compiler cannot compute must be a refusal; a size it CAN compute
must be the number. Both were being absorbed instead.

WHERE THE EVALUATOR LIVES, AND WHY. In `ck_resolve::const_values` — the module
`const` fold — as a second ENTRY POINT, not a second evaluator. The two
candidates were that fold (CST-shaped, holds the registry) and
`ck_types::const_eval` (ConstExpr-shaped). The second was checked and rejected:
reaching it means `ConstEvalBodies` + the coherence table + prepared bodies,
none of which exist at lift time, so `lift::impl_head::build_value_expr` +
a leaf resolver would have meant writing a fresh ConstExpr walker — a THIRD
evaluator wearing a reused constructor. The fold, by contrast, already owns
every piece the type slot needs: `arith_method` (which reads the operator's
method name off `ck_parser::standard_operator_table` through the shared
`lower::op_token` — no glyph is matched in Rust), `fold_arith`'s checked
integer set, and now one `read_int_text`. `fold_generic_value_expr` adds a
walk over the parser's other CST shape and nothing else; the leaves differ
only in that a type slot reads the settled `Interner::const_int` registry the
same fold filled during linking, because by then linking has run. One frame,
one arithmetic, two shapes — so `(PAGE - 1) + LEXEME` cannot mean one number
in a `const` initializer and another in a size slot.

The cursor now advances once per ARGUMENT NODE in both `lift_generic_args` and
`param_args::check_type_expr`, unconditionally, foldable or not. That is the
half that fixes the misdiagnosis, and it is the half that has to hold whatever
new node kinds the parser grows. (`WildcardType` was checked for the identical
hole and does not have it: `parse_generic_args` takes `_` as a bare token
before `parse_type_expr` could wrap it, so no `WildcardType` node ever reaches
the slot walk. The new arm would absorb it correctly if that ever changed.)

E0742 now names the third legal spelling and blames the expression at its own
span. Still one fact: this slot needs a number the compiler has, and this
argument is not one.

DEFECT 2 — THE STDLIB-HEAD BLIND SPOT — IS DIAGNOSED, NOT CLOSED, AND THAT IS
DELIBERATE. `param_args` resolves its head with a per-module `scope.lookup`
while the lift resolves the same head through the project-global nominal
roster, so a stdlib head always misses in an app module and the whole slot
check is skipped: `record Holder { bytes: List<byte, WOBBLY> }` checks clean
and the field absorbs to unbounded. Same class as `list_literal_nominal`'s
lost size determinism (rule V6b). The fallback was written and verified — it
closes that case exactly. It does not land, because it also turns 46 stdlib
signatures into E0742 (18 sites in `tests/corpus/stdlib/List.ck`) and reds
`stdlib_type_clean`. Those spell a FREE size binder `n`; List.ck's header
calls that the idiom, E0742's rule calls it a refusal, and the capability cell
`impl_method_signature_size_param` declares that `fn count(c: List<Int, n>)`
reaches CODEGEN — which is only observable if it is not a type error first.
Three owner-authored artifacts, two answers. The Laws do not decide between
them, so it is one question for the owner and not a thing to settle from a
slice. The blind spot is recorded where the next reader will hit it: in
`check_type_expr` at the lookup, and in the cell that already existed to name
it. The multi-segment `Mod::SIZE` half is untouched, as instructed.

- `ck_resolve::const_values`: `fold_generic_value_expr` + `fold_value_expr` +
  `fold_value_atom`, over the existing `arith_method` / `fold_arith`; the
  literal reader is factored to `read_int_text` so `1_000` reads the same in
  both entry points.
- `ck_types::lift::value_slot`: `value_slot_expr`, and the unconditional
  cursor advance with an `Unknown` fill for a node the lift has no reading for.
- `ck_types::param_args`: the same cursor rule, `value_slot_expr` in the legal
  set, and the recorded blind spot.
- E0742's message and doc; three `tests/types` goldens re-blessed.
- Cells: `a_size_slot_whose_arithmetic_does_not_fold_refuses` (new,
  `CELL_COUNT` 428 -> 429); `a_size_slot_whose_const_does_not_fold_refuses`'s
  position note now carries the measured reason it is still app-owned.
- Tests: three `param_args` unit tests (the `Pair2<1 + 1, Int>` misdiagnosis
  pinned exactly), `tests/types/param_value_expr_arg`, and
  `sizes_query::a_size_slot_spelled_as_arithmetic_sizes_to_the_folded_number`
  over the new `sizes_value_expr` fixture — 208 B of record that used to be
  three unbounded fields.

Gate: NOT run. The owner suspended `./scripts/test-rotate.sh` mid-slice
(package at 87 C, one core pinned by four agents' single-threaded test phases)
and will run it serialized. Verified narrowly instead, all green: `cargo fmt
--check`; `cargo clippy --workspace --all-targets -D warnings` (0/0);
`ck_types` 261, `ck_resolve` 113, `ck_parser`/`ck_syntax`/`ck_lex`/`ck_hir`
unit tests; `ck_driver` conformance, sizes_query, architecture (R3/R4 and V6b
included), stdlib_type_clean, stdlib_composes_silence, grammar_stage1 — the
last three being exactly the targets the withheld fallback had turned red.
`--test capability` is unverified: it executes CkLang in a container, which
the owner forbade for the rest of this slice.

@@ -317,0 +387,4 @@
+        }
+        (Some(inner), None, None) => fold_value_expr(inner, src, scope, interner, depth + 1),
+        (None, None, None) => fold_value_atom(node, src, scope, interner),
+        _ => None,

@@ -95,0 +91,4 @@
+    /// [`NameToken`]s and threw it away, which is how a `fn`'s value binder came
+    /// to be silently allocated a type variable.
+    #[must_use]
+    pub fn generic_params(&self) -> Vec<crate::TypeParam<'a>> {

@@ -0,0 +286,4 @@
+}
+
+/// The source text a token span covers.
+fn tok_text(span: Span, src: &str) -> &str {