fused_group / group: rename CD_INSERT caller's 'val' to 'row_val'

The CD_INSERT macro at src/ops/group.c:1038 defines an internal
'int64_t val = (VAL_EXPR);' from its argument.  The has-nulls
fallback loop earlier in the same function declared its own
'int64_t val' in the outer scope and then called CD_INSERT(val).
After macro expansion that became 'int64_t val = (val);' — clang
on macOS flags it as -Werror,-Wuninitialized.  gcc didn't notice.

Renaming the outer variable to row_val avoids the shadowing.  Only
the fallback callsite needed the rename; the fast-path loops were
already passing distinct expressions (d[r], v, etc.).

Caught with a local CC=clang build matching CI's compiler.  Last
build error this commit fixes; clang release build is now clean
and the test matrix is 2335 / 2336 passing, 0 failed.

Author: singaraiona

src/ops/group.c

@@ -1111,16 +1111,19 @@ ray_t* ray_count_distinct_per_group(ray_t* src, const int64_t* row_gid,
             int64_t gid = row_gid[r];
             if (gid < 0 || gid >= n_groups) continue;
             if (null_bm && ((null_bm[r/8] >> (r%8)) & 1)) continue;
-            int64_t val;
+            /* Use a different name from the macro's inner `val` so
+             * clang doesn't see an `int64_t val = (val);` self-init
+             * after macro expansion. */
+            int64_t row_val;
             if (in_type == RAY_F64) {
                 double fv = ((double*)base)[r];
                 if (fv != fv) fv = (double)NAN;
                 else if (fv == 0.0) fv = 0.0;
-                memcpy(&val, &fv, sizeof(int64_t));
+                memcpy(&row_val, &fv, sizeof(int64_t));
             } else {
-                val = read_col_i64(base, r, in_type, src->attrs);
+                row_val = read_col_i64(base, r, in_type, src->attrs);
             }
-            CD_INSERT(val);
+            CD_INSERT(row_val);
         }
     }