Add a maps extension with maps.merge

[lopster568]

Description

CEL has no way to combine two maps. The + operator concatenates strings, bytes, and lists, but has no map overload, and there is no maps extension.

This adds one, with a single function:

maps.merge(map(K, V), map(K, V)) -> map(K, V)

It returns a new map holding the entries of both arguments, with the second argument's values winning on conflicting keys. Neither input is modified. The merge is shallow, so a value that is itself a map is replaced rather than merged recursively.

maps.merge({}, {})                              // {}
maps.merge({'a': 1}, {'b': 2})                  // {'a': 1, 'b': 2}
maps.merge({'a': 1}, {'a': 2})                  // {'a': 2}
maps.merge({'a': {'x': 1}}, {'a': {'y': 2}})    // {'a': {'y': 2}}

Scope

This is deliberately only the replace step from #1240. @TristonianJones suggested starting there:

I think replace semantics is where I'd start -- last write wins, followed by set-if-absent as the deep merge is the trickiest case

So set-if-absent and recursive merge are left for follow-ups rather than guessed at here.

On the API shape, I went with a bare maps.merge(a, b) in a new maps namespace rather than a single entry point taking a strategy argument, because that is what the existing libraries do: sets.contains / sets.equivalent / sets.intersects, math.ceil / math.floor / math.abs. No function in ext takes a mode or strategy parameter today, so a later maps.mergeIfAbsent would fit that pattern without changing this signature. Happy to reshape it if you would rather have something else.

Implementation notes

• Cost estimation and tracking scale with the combined size of both inputs plus map allocation, following ext/sets.go. Without them the checker would price this as a fixed cost of 1 despite the O(n+m) copy.
• mapAllocCost is added to ext/costs.go alongside the existing listAllocCost.
• Registered in ext/extension_option_factory.go (factory and alias) and in repl/evaluator.go.
• ext/README.md gains a Maps section in the style of the surrounding entries.

Testing

ext/maps_test.go covers empty inputs, disjoint keys, conflicting keys, nested maps being replaced rather than merged, non-string keys, merging a variable, associativity over disjoint keys, compile-time rejection of non-map arguments, non-map arguments at runtime, and that the cost estimate scales with input size and brackets the tracked cost.

go build ./..., go test ./..., go vet ./ext/... and gofmt are clean.

[TristonianJones]

Let's maybe call this something other than merge.

A couple of good examples might be putAll (Java convention) or extend (Rust) since merge might imply semantics like combining the values of a colliding key.

I'm inclined toward putAll since it's easy to document what it does, and you could have other methods like <map(K,V)>.put(K, V) -> map(K,V) if you need to update a specific key (and you might want to add <map(K,V)>.remove(K) -> map(K,V), <map(K,V)>.removeAll(<list(K)>) -> map(K,V), map(K,V).keys(), map(K,V).values() while you're at it)

[TristonianJones]

I'm in the process of overhauling the cost framework, so this is fine for now, but please add a TODO to update this method once the new model is available.

[TristonianJones]

Consider using the folder interfaces to manage setting entries from traits.Foldable