refactor(interpreter,value): insert_if_absent; consolidate Serialize

- Two interpreter rule-output sites that read
  get_or_insert_with(p, || value.clone()) /
  get_or_insert_with(p, || output.clone()) now use the new
  Object::insert_if_absent helper — same semantics, no closure
  indirection.
- Value::Serialize for Value::Object now delegates to
  Object::serialize so there is a single canonical serialization
  path. The duplicated copy in value.rs handled non-string-key
  stringification, but Object's own impl already does the same.
- as_set / as_set_mut / as_object / as_object_mut doctest snippets
  updated to use Set / Object instead of BTreeSet / BTreeMap.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: anakrish

src/builtins/encoding.rs

@@ -308,7 +308,7 @@ fn urlquery_encode_object(
 
     {
         let mut pairs = url.query_pairs_mut();
-        for (key, value) in obj.iter() {
+        for (key, value) in obj.iter_sorted() {
             let key = ensure_string(name, &params[0], key)?;
             match value {
                 Value::String(v) => {

src/builtins/strings.rs

@@ -199,15 +199,15 @@ fn to_string(v: &Value, unescape: bool) -> String {
         }
         Value::Set(s) => {
             "{".to_owned()
-                + &s.iter()
+                + &s.iter_sorted()
                     .map(|e| to_string(e, true))
                     .collect::<Vec<String>>()
                     .join(", ")
                 + "}"
         }
         Value::Object(o) => {
             "{".to_owned()
-                + &o.iter()
+                + &o.iter_sorted()
                     .map(|(k, v)| to_string(k, true) + ": " + &to_string(v, true))
                     .collect::<Vec<String>>()
                     .join(", ")
@@ -568,7 +568,7 @@ fn replace_n(span: &Span, params: &[Ref<Expr>], args: &[Value], _strict: bool) -
     let mut s = ensure_string(name, &params[1], &args[1])?;
 
     let span = params[0].span();
-    for item in obj.as_ref().iter() {
+    for item in obj.as_ref().iter_sorted() {
         match item {
             (Value::String(k), Value::String(v)) => {
                 s = s.replace(k.as_ref(), v.as_ref()).into();

src/interpreter.rs

@@ -1693,7 +1693,7 @@ impl Interpreter {
                         // TODO: clean this assumption between Undefined vs Object.
                         obj.get_or_insert_with(p, Value::new_object);
                     } else {
-                        let existing = obj.get_or_insert_with(p, || value.clone());
+                        let existing = obj.insert_if_absent(p, value.clone());
                         if *existing != value {
                             bail!(span.error("complete rules should not produce multiple outputs"))
                         }
@@ -1823,7 +1823,7 @@ impl Interpreter {
                 // Non-set rule.
                 let key = Value::from_array(comps);
                 let obj_mut = ctx_mut.rule_value.as_object_mut()?;
-                let existing = obj_mut.get_or_insert_with(key, || output.clone());
+                let existing = obj_mut.insert_if_absent(key, output.clone());
                 if *existing != output {
                     bail!(rule_ref
                         .span()

src/value.rs

@@ -24,7 +24,7 @@ use core::str::FromStr;
 
 use anyhow::{anyhow, bail, Result};
 use serde::de::{self, Deserializer, Error as DeError, MapAccess, SeqAccess, Visitor};
-use serde::ser::{SerializeMap, Serializer};
+use serde::ser::Serializer;
 use serde::{Deserialize, Serialize};
 
 use crate::*;
@@ -87,26 +87,15 @@ impl Serialize for Value {
     where
         S: Serializer,
     {
-        use serde::ser::Error;
         match self {
             Value::Null => serializer.serialize_unit(),
             Value::Bool(b) => serializer.serialize_bool(*b),
             Value::String(s) => serializer.serialize_str(s.as_ref()),
             Value::Number(n) => n.serialize(serializer),
             Value::Array(a) => a.serialize(serializer),
-            Value::Object(fields) => {
-                let mut map = serializer.serialize_map(Some(fields.len()))?;
-                for (k, v) in fields.iter_sorted() {
-                    match k {
-                        Value::String(_) => map.serialize_entry(k, v)?,
-                        _ => {
-                            let key_str = serde_json::to_string(k).map_err(Error::custom)?;
-                            map.serialize_entry(&key_str, v)?
-                        }
-                    }
-                }
-                map.end()
-            }
+            // Delegate to the Object/Set serializers — single canonical path,
+            // handles non-string-key stringification internally.
+            Value::Object(fields) => fields.serialize(serializer),
 
             // display set as an array
             Value::Set(s) => s.serialize(serializer),
@@ -1241,13 +1230,12 @@ impl Value {
     /// Cast value to [`&Set`] if [`Value::Set`].
     /// ```
     /// # use regorus::*;
-    /// # use std::collections::BTreeSet;
     /// # fn main() -> anyhow::Result<()> {
     /// let v = Value::from(
     ///    [Value::from("Hello")]
     ///        .iter()
     ///        .cloned()
-    ///        .collect::<BTreeSet<Value>>(),
+    ///        .collect::<Set>(),
     /// );
     /// assert_eq!(v.as_set()?.first(), Some(&Value::from("Hello")));
     /// # Ok(())
@@ -1262,13 +1250,12 @@ impl Value {
     /// Cast value to [`&mut Set`] if [`Value::Set`].
     /// ```
     /// # use regorus::*;
-    /// # use std::collections::BTreeSet;
     /// # fn main() -> anyhow::Result<()> {
     /// let mut v = Value::from(
     ///    [Value::from("Hello")]
     ///        .iter()
     ///        .cloned()
-    ///        .collect::<BTreeSet<Value>>(),
+    ///        .collect::<Set>(),
     /// );
     /// v.as_set_mut()?.insert(Value::from("World"));
     /// # Ok(())
@@ -1283,13 +1270,12 @@ impl Value {
     /// Cast value to [`&Object`] if [`Value::Object`].
     /// ```
     /// # use regorus::*;
-    /// # use std::collections::BTreeMap;
     /// # fn main() -> anyhow::Result<()> {
     /// let v = Value::from(
     ///    [(Value::from("Hello"), Value::from("World"))]
     ///        .iter()
     ///        .cloned()
-    ///        .collect::<BTreeMap<Value, Value>>(),
+    ///        .collect::<Object>(),
     /// );
     /// assert_eq!(
     ///    v.as_object()?.iter().next(),
@@ -1307,13 +1293,12 @@ impl Value {
     /// Cast value to [`&mut Object`] if [`Value::Object`].
     /// ```
     /// # use regorus::*;
-    /// # use std::collections::BTreeMap;
     /// # fn main() -> anyhow::Result<()> {
     /// let mut v = Value::from(
     ///    [(Value::from("Hello"), Value::from("World"))]
     ///        .iter()
     ///        .cloned()
-    ///        .collect::<BTreeMap<Value, Value>>(),
+    ///        .collect::<Object>(),
     /// );
     /// v.as_object_mut()?.insert(Value::from("Good"), Value::from("Bye"));
     /// # Ok(())