fix(transform): WITH detects nested aggregates for implicit GROUP BY

Companion to the iter-33 transform_return.c fix. The WITH clause has
its own aggregate-detection at line ~419 that only set has_aggregate
when the projection item's TOP-LEVEL expression was a function call.
Aggregates buried in binary ops, list/map literals, or subscripts
were missed.

Symptom (With6 [6]):
  MATCH ... WITH me.age AS age, you
  WITH age, age + count(you.age) AS agg
  RETURN *

  -- Empty-input result was 1 all-null row (no GROUP BY → ungrouped agg).
  -- Spec: 0 rows.

Two changes:
1. Extended find_aggregating_call() to walk MAP and SUBSCRIPT nodes
   in addition to FUNCTION_CALL/BINARY_OP/NOT/PROPERTY/NULL_CHECK/LIST.
2. The else-branch (BINARY_OP / map / etc.) now calls
   find_aggregating_call() after the projection emits and sets
   has_aggregate = true if any aggregate is found nested inside —
   this triggers the existing GROUP BY emission on the non-aggregate
   columns.

TCK delta: pass=3456 -> 3458 (+2), fails -2. With6 [6]/[7].
944/944 unit, functional clean.

Author: Dylan Bobby Storey

src/backend/transform/transform_with.c

@@ -77,6 +77,22 @@ static const char *find_aggregating_call(ast_node *expr)
                 if (r) return r;
             }
         }
+    } else if (expr->type == AST_NODE_MAP) {
+        cypher_map *m = (cypher_map*)expr;
+        if (m->pairs) {
+            for (int i = 0; i < m->pairs->count; i++) {
+                cypher_map_pair *mp = (cypher_map_pair*)m->pairs->items[i];
+                if (mp) {
+                    const char *r = find_aggregating_call(mp->value);
+                    if (r) return r;
+                }
+            }
+        }
+    } else if (expr->type == AST_NODE_SUBSCRIPT) {
+        cypher_subscript *s = (cypher_subscript*)expr;
+        const char *r = find_aggregating_call(s->expr);
+        if (r) return r;
+        return find_aggregating_call(s->index);
     }
     return NULL;
 }
@@ -464,6 +480,14 @@ int transform_with_clause(cypher_transform_context *ctx, cypher_with *with)
             ctx->sql_size = saved_size;
             strcpy(ctx->sql_buffer, saved_buffer);
             free(saved_buffer);
+
+            /* Check for nested aggregates (e.g. `age + count(x)` or
+             * `{kids: collect(x)}`). Without this, the implicit GROUP BY
+             * isn't emitted and a grouped-aggregate-on-empty produces 1
+             * all-null row instead of 0 rows. (With6 [6]/[7].) */
+            if (find_aggregating_call(item->expr) != NULL) {
+                has_aggregate = true;
+            }
         }
     }