[Arith] `floormod(x * c1 + y, c2)` rewrite breaks `DetectIterMap` on fused div/mod maps

[LeiWang1999]

The rewrite added in #11287:

floormod(x * c1 + y, c2) -> floormod(x * floormod(c1, c2) + y, c2)

is algebraically valid for one expression, but it can break DetectIterMap when
the modulo expression is paired with a matching quotient expression from the
same fused index.

For example, this map is a straightforward split of one flat index:

flat = i * 192 + j
lane = flat % 128
reg = flat // 128

DetectIterMap([lane, reg]) succeeds before the rewrite. After simplifying
only lane to (i * 64 + j) % 128, the tuple no longer exposes the same fused
source expression, and iter-map detection fails.

Minimal Reproducer

import tvm
from tvm import tirx as tir
from tvm.arith.iter_affine_map import IterMapLevel

from tvm.ir import Range

i = tir.Var("i", "int32")
j = tir.Var("j", "int32")

input_iters = {
 i: Range(0, 64),
 j: Range(0, 192),
}

flat = i * 192 + j
lane = flat % 128
reg = flat // 128

analyzer = tvm.arith.Analyzer()
simplified_lane = analyzer.simplify(lane)

print("lane =", lane)
print("simplified_lane =", simplified_lane)

raw = tvm.arith.detect_iter_map(
 [lane, reg],
 input_iters,
 predicate=True,
 check_level=IterMapLevel.Bijective,
)
print("raw errors =", list(raw.errors))

simplified = tvm.arith.detect_iter_map(
 [simplified_lane, reg],
 input_iters,
 predicate=True,
 check_level=IterMapLevel.Bijective,
)
print("simplified errors =", list(simplified.errors))

Why This Matters

This pattern appears in layout analysis for GPU code generation. A layout often
splits a flat logical index into:

thread = flat % num_threads
index = flat // num_threads

The original pair:

[(i * 192 + j) % 128, (i * 192 + j) // 128]

is recognized as a structured bijective map. After local simplification:

[(i * 64 + j) % 128, (i * 192 + j) // 128]

the two outputs no longer share the same visible fused source, so iter-map
analysis rejects the map even though the mapping is still semantically valid.

TileLang carries a local patch that restores the old conservative condition:

 TVM_TRY_REWRITE_IF(
 floormod(x * c1 + y, c2),
 floormod(x * floormod(c1, c2) + y, c2),
- c2.Eval()->value > 0);
+ c2.Eval()->value > 0 && c1.Eval()->value % c2.Eval()->value == 0);

If there is a better way to preserve this optimization while keeping iter-map detection robust, I would be happy to discuss it.

cc @junrushao

[tqchen]

i think we can go with what @LeiWang1999 suggested, and have a regression, cc @Ubospica @tlopex