[fix](fe) Defer multi distinct count variant check

### What problem does this PR solve?

Issue Number: close #25672

Related PR: #63479

Problem Summary: MultiDistinctCount checked argument types while sync MV SQL was still unbound, so sync MV context generation skipped multi_distinct_count MVs. Defer the variant rejection to the post-rewrite legality check and keep array arguments valid.

### Release note

None

### Check List (For Author)

- Test: Unit Test
    - FE unit test: ./run-fe-ut.sh --run org.apache.doris.nereids.trees.expressions.functions.agg.CountTest
- Behavior changed: No
- Does this need documentation: No

Author: eldenmoon

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MultiDistinctCount.java

@@ -57,9 +57,6 @@ private MultiDistinctCount(boolean distinct, List<Expression> children) {
         if (super.children().size() > 1) {
             throw new AnalysisException("MultiDistinctCount's children size must be 1");
         }
-        for (Expression argument : super.children()) {
-            Count.checkVariantArgument(argument, "COUNT DISTINCT " + argument.toSql());
-        }
     }
 
     /** constructor for withChildren and reuse signature */
@@ -70,10 +67,14 @@ protected MultiDistinctCount(AggregateFunctionParams functionParams) {
     @Override
     public MultiDistinctCount withDistinctAndChildren(boolean distinct, List<Expression> children) {
         Preconditions.checkArgument(children.size() == 1, "MultiDistinctCount's children size must be 1");
-        for (Expression argument : children) {
+        return new MultiDistinctCount(getFunctionParams(false, children));
+    }
+
+    @Override
+    public void checkLegalityAfterRewrite() {
+        for (Expression argument : getArguments()) {
             Count.checkVariantArgument(argument, "COUNT DISTINCT " + argument.toSql());
         }
-        return new MultiDistinctCount(getFunctionParams(false, children));
     }
 
     @Override

fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/functions/agg/CountTest.java

@@ -17,12 +17,21 @@
 
 package org.apache.doris.nereids.trees.expressions.functions.agg;
 
+import org.apache.doris.common.Pair;
+import org.apache.doris.nereids.analyzer.UnboundSlot;
 import org.apache.doris.nereids.exceptions.AnalysisException;
+import org.apache.doris.nereids.rules.exploration.mv.rollup.SingleCombinatorRollupHandler;
+import org.apache.doris.nereids.trees.expressions.Expression;
 import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.expressions.functions.combinator.StateCombinator;
+import org.apache.doris.nereids.trees.expressions.functions.combinator.UnionCombinator;
 import org.apache.doris.nereids.types.ArrayType;
 import org.apache.doris.nereids.types.IntegerType;
 import org.apache.doris.nereids.types.VariantType;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -39,8 +48,10 @@ void testCountDistinctRejectsVariant() {
 
     @Test
     void testMultiDistinctCountRejectsVariant() {
+        MultiDistinctCount count = new MultiDistinctCount(SlotReference.of("v", VariantType.INSTANCE));
+
         AnalysisException exception = Assertions.assertThrows(AnalysisException.class,
-                () -> new MultiDistinctCount(SlotReference.of("v", VariantType.INSTANCE)));
+                count::checkLegalityAfterRewrite);
         Assertions.assertTrue(exception.getMessage().contains("COUNT DISTINCT does not support VARIANT argument"));
         Assertions.assertTrue(exception.getMessage().contains("Cast the VARIANT expression"));
     }
@@ -50,4 +61,23 @@ void testMultiDistinctCountAllowsArray() {
         Assertions.assertDoesNotThrow(
                 () -> new MultiDistinctCount(SlotReference.of("arr", ArrayType.of(IntegerType.INSTANCE))));
     }
+
+    @Test
+    void testMultiDistinctCountAllowsUnboundArgumentBeforeLegalityCheck() {
+        Assertions.assertDoesNotThrow(() -> new MultiDistinctCount(new UnboundSlot("kint")));
+    }
+
+    @Test
+    void testMultiDistinctCountCanRollupFromUnionState() {
+        SlotReference kint = SlotReference.of("kint", IntegerType.INSTANCE);
+        MultiDistinctCount queryFunction = new MultiDistinctCount(kint);
+        StateCombinator stateCombinator = StateCombinator.create(queryFunction);
+        UnionCombinator unionCombinator = new UnionCombinator(ImmutableList.of(stateCombinator), queryFunction);
+        SlotReference mvSlot = SlotReference.of("__multi_distinct_count_1", unionCombinator.getDataType());
+        Pair<Expression, Expression> mvExprToMvScanExprPair = Pair.of(unionCombinator, mvSlot);
+
+        Assertions.assertTrue(SingleCombinatorRollupHandler.INSTANCE.canRollup(
+                queryFunction, queryFunction, mvExprToMvScanExprPair,
+                ImmutableMap.of(unionCombinator, mvSlot)));
+    }
 }