Move ColumnReplicated materialization to the top of the per-column loop
in insertChunk, before hasDynamicStructure/hasStatistics branches. This
prevents ColumnDynamic::insertRangeFrom from receiving a ColumnReplicated
source (causing assert_cast crash in debug/sanitizer, UB in release).

The previous code had the replicated guard after dynamic/statistics
branches, so ColumnReplicated(ColumnDynamic) would enter the
hasDynamicStructure path first and crash.

Also adds a regression test with ColumnReplicated(ColumnDynamic) in
insertChunk to cover this specific code path.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

…stination

Based on @Avogar's review feedback on PR #101036, this commit redesigns the
fix for the `STID 2508` family `MergedData` type mismatch exception
(`isConst() || isSparse() || isReplicated()` assertion at `IColumn.h:862`).

Previous fix (reverted here) materialized all `ColumnReplicated` columns in
the merge algorithms' `consume` methods, which killed the lazy replication
optimization for every late-arriving chunk. It also materialized sources
in `MergedData::insertRow` / `insertRows`, losing the optimization on
every row insertion.

New approach: detect the mismatch in `MergedData` and WRAP the destination
in `ColumnReplicated` using the identity-indexes constructor. After
wrapping, `ColumnReplicated::insertFrom` / `insertRangeFrom` consume both
regular and replicated sources through the same optimized path, preserving
the lazy replication optimization for the entire merged output.

Changes:

1. Revert `removeReplicatedFromAllColumns` in all 5 merge algorithm
   `consume` methods. Restore `removeReplicatedFromSortingColumns`, which
   only materializes sort columns — non-sort `ColumnReplicated` columns
   now flow through to `MergedData` unchanged.

2. In `MergedData::insertRow` and `insertRows`: when the source is
   `ColumnReplicated` but the destination is regular, wrap the destination
   in `ColumnReplicated` via `ColumnReplicated::create(std::move(columns[i]))`.
   The identity-indexes constructor is a structural wrap — existing data
   is preserved in `nested_column` with indexes `[0, 1, ..., N-1]`.

3. In `MergedData::insertChunk`: drop the eager up-front materialization.
   Handle each branch on its own terms:
   - `hasDynamicStructure` wraps the empty destination in `ColumnReplicated`
     when the chunk is replicated, so `ColumnReplicated::insertRangeFrom`
     handles the source (not `ColumnDynamic::insertRangeFrom`, which would
     `assert_cast` a `ColumnReplicated` source).
   - `hasStatistics` works unchanged — `takeOrCalculateStatisticsFrom` is
     delegated through `ColumnReplicated` to the nested column.
   - `columns[i]->isReplicated()` handles a replicated chunk via
     `std::move` instead of re-wrapping.
   - The simple else branch lets `ColumnReplicated` chunks flow through,
     so the merged destination inherits the optimization.

4. Rewrite `gtest_merged_data_replicated.cpp`:
   - Keep regression tests for `insertRow` / `insertRows` / `insertChunk`
     covering regular destination + `ColumnReplicated` source, including
     `ColumnReplicated(ColumnDynamic)`.
   - Add `InsertRowsWrapsDestinationPreservingOptimization` which asserts
     the merged destination is `ColumnReplicated` after mismatch handling
     (not materialized as regular).

Reproduction note: over ~3 weeks of attempts I could not reproduce the
assertion failure through SQL or integration tests — it requires the
stress-test-scale parallelism + sanitizer timing that CI provides. The
gtests exercise the exact conditions that arrive at `MergedData` under
that environment.

…ted-merge-crash

Fix ColumnReplicated type mismatch crash in merge algorithms