[mlir][Vector]  Promote buffers accessed via dynamic subviews (#217793)

**Motivation**

An op on dynamically-shaped tensors is padded to static tile sizes
before vectorization: its operands are padded up to a fixed size, and
the real region is extracted back from the result. After bufferization
those padded tensors become fixed-size buffers, and the IR around them
reaches each buffer through dynamic-shaped views — the buffer's shape is
static, but the part that really holds data is not.

The pattern looks like this: a fixed-size staging buffer holding one
tile, a dynamic subview covering the part with real data, a reshape
lifting that tile to the rank of the original tensor it came from, and a
memref.copy that stores the tile back into it or loads a tile out.

```mlir
%buf = memref.alloca() : memref<128x64xf16>      // padded staging buffer
vector.transfer_write %v, %buf[%c0, %c0] {in_bounds = [true, true]}
    : vector<128x64xf16>, memref<128x64xf16>
%sv  = memref.subview %buf[0, 0] [%n, 64]  [1, 1]   // %n rows of the padded buffer, %n may <128 for the edge tile 
    : memref<128x64xf16> to memref<?x64xf16, strided<[64, 1]>>
             ...                                     // ops on the dynamic subview like repadding + elewise/reduction
%ex  = memref.expand_shape %sv [[0, 1, 2], [3]]
    : memref<?x64xf16, strided<[64, 1]>> into memref<1x1x?x64xf16, strided<[?, ?, 64, 1]>>
%dst = memref.subview %out[%i, %j, %k, 0]  [1, 1, %n, 64] [1, 1, 1, 1]   // the tile's window in %out: %k is where it starts, %n how long it is
memref.copy %ex, %dst
```

#211880 taught Mem2Reg to promote a staticall vector SSA value, but only
for whole-buffer,in-bounds, unmasked
vector.transfer_read/transfer_write, plus fully-static memref.subview
sub-slices.

This PR extends the vector Mem2Reg models so dynamic subviews and masked
transfers promote as well. Any partial access is reconstructed with an
arith.select during promotion instead of bailing out. The chain above
then promotes to vector values, and the allocation goes away.

This PR closes a gap in the lowering pipeline for linalg IR on
dynamically-shaped tensors: tile-and-fuse → padding → vectorize →
bufferization → mem2reg. The current Mem2Reg handles only whole-buffer
transfers and static-shaped subviews, so the staging buffers remain in
the final IR. Now they promote to vector values instead: the padding
introduced at the linalg level becomes a vector.create_mask and an
arith.select on a fixed-size vector, and the pipeline finishes in pure
vector IR.

The expand_shape and collapse_shape will be supported in a separate PR. 

**What this PR adds**

**Dynamic-shaped subviews.** A vector's shape has to be static, so a
dynamic subview cannot have a vector of its own shape. It uses the whole
buffer's vector instead, and reads or writes through it are masked to
the runtime size with vector.create_mask and arith.select. The subview
has to start at the buffer's origin, so the live region on each
dimension is just [0, size).

**Masked transfers.** A masked transfer touches only some lanes, so
rather than reject it, promotion rebuilds the result with an
arith.select.

**Restrictions**
- a transfer that does not start at the buffer's origin, or whose
permutation map is not the identity
 - a subview whose offsets are not constants
 - a dynamic subview that does not start at the buffer's origin
 - a rank-reducing or non-unit-stride subview
- subviewing or reshaping a scalable buffer — it still promotes through
whole-buffer transfers, just not through these

**Tests**
- mem2reg.mlir covers whole-buffer, static-subview, masked cases. 
- mem2reg-dynamic-subview.mlir covers dynamic views: plain, nested on a
static subview, and merged across a branch by a block argument.
 
 assisted-by-claude

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>