Follow-up cleanups to the dependent tile-end support: remove the ways the
three inner-loop lowerings could drift, and drop a config knob that the
resident lowering silently ignored.

- Build LoopDimInfo through one _loop_dim_infos helper.  The three lowerings
  each constructed it separately and the resident loop had fallen out of
  step, omitting end_expr.  Setting it changes no generated code.
- Allocate the resident loop's carry tuple through new_var.  Two sibling
  bodies in one kernel both emitted a bare _carry; a nested one would have
  shadowed the enclosing carry and silently rebound reads of it.
- Drop pallas_pre_broadcast when the loop type cannot apply it.  The
  transform widens loop-carried VMEM scratch, which the resident lowering
  does not allocate, so both settings were autotuning as distinct configs
  that generate one kernel.
- Spell out which bound forms _ordered_source_end accepts, and name the two
  other places that recognize the same shape and have to move with it:
  tracing_ops._dependent_tile_end_expr for kernels with no worklist plan,
  and tile_strategy._fold_tile_end_op for every backend.
- Delete the worklist search gating tests: they assert behavior keyed on
  ConfigSpec.pallas_worklist_search_enabled, which does not exist.  Replace
  the recognizer test with test_dependent_bound_grammar, covering accepted
  and rejected forms and both begin-matching rules.

Generated code is unchanged across 42 kernel/config combinations spanning
every loop type, grouping, and both dense and worklist paths, except for
the intended carry rename.

_lift_sympy_arg returned the loop offset for the whole GridOrigin family,
but only a tile's begin is the offset.  TileEndOrigin, TileCountOrigin and
TileIdOrigin each render as a compound expression, so a symbol carrying one
of those origins was silently replaced by the tile's begin.

This is reachable whenever such a symbol survives into a sympy expression
instead of its own op.  min()/max() do exactly that: they are device
function replacements that fold their operands into a single sympy Min/Max
at trace time, dropping the tile_end node.  So

    for tile_k in hl.tile(0, min(n, tile_q.end)):

lowered its trip count from tile_q.begin -- zero iterations on the first
tile, and short by one block on every later one.  tile.count collapsed the
same way (begin instead of cdiv), as did tile.id (begin instead of
offset // block).  Plain arithmetic on a tile edge (tile.end + 8) keeps the
op and was never affected, nor was min() over tile.begin, which is what the
offset already meant.

Dispatch on the concrete origin instead.  The block id is resolved before
rendering and carried into a replaced copy, because host_str() looks up
offset_var and active_device_loops by block id and an aliased symbol's own
block may have no active loop.  The rendered edge is parenthesized: it
becomes a sympy Symbol name inside the enclosing expression, so an
unbracketed tile.id would turn 2 * (offset // block) into
(2 * offset) // block.

Covered for all three edges under both ops, on an input whose final tile is
partial.  The test is Triton-only: Pallas lowers a dependent tile bound
through its own loop codegen and never reaches this path, so its generated
code is unchanged across 42 kernel/config combinations.