refactor(rvm): migrate to Object/Set API; snapshot IterationState pairs

Migrates ~55 sites across src/rvm/ to the new Object/Set API.

IterationState refactor (replaces BTreeMap::range / BTreeSet::range
loop resumption):
- IterationState::Object now stores Rc<[(Value, Value)]> + pos.
  No second BTreeMap::get during iteration; no defensive None branch.
  Symmetric with IterationState::Set { values, pos }.
- Snapshot is built via iter() / keys() — matches the interpreter's
  iteration contract, preserving dual-path equivalence.
- Per-push check_memory_limit_if_needed() during snapshot
  construction maintains the allocator-limit guarantee even for
  large input collections.

Drops dead clones of iteration_key/iteration_value in the
suspendable comprehension yield path.

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

Author: anakrish

src/rvm/program/metadata.rs

@@ -11,9 +11,9 @@
 //! values are converted through [`MetadataValue`] — a postcard/bincode-safe
 //! enum that avoids `deserialize_any`.
 
+use crate::collections::{Object, Set};
 use crate::Rc;
-use alloc::collections::BTreeMap;
-use alloc::collections::BTreeSet;
+use alloc::collections::{BTreeMap, BTreeSet};
 use alloc::string::String;
 use alloc::vec::Vec;
 use serde::{Deserialize, Serialize};
@@ -52,7 +52,7 @@ impl ProgramMetadata {
     pub fn to_value(&self) -> crate::value::Value {
         use crate::value::Value;
 
-        let mut obj = BTreeMap::new();
+        let mut obj = Object::new();
         obj.insert(
             Value::String("compiler_version".into()),
             Value::String(self.compiler_version.as_str().into()),
@@ -75,7 +75,7 @@ impl ProgramMetadata {
         );
 
         if !self.annotations.is_empty() {
-            let mut annotations_obj = BTreeMap::new();
+            let mut annotations_obj = Object::new();
             for (k, v) in &self.annotations {
                 annotations_obj.insert(Value::String(k.as_str().into()), v.clone());
             }
@@ -198,7 +198,7 @@ impl MetadataValue {
         match *self {
             MetadataValue::String(ref s) => Value::String(s.as_str().into()),
             MetadataValue::StringSet(ref set) => {
-                let mut bset = alloc::collections::BTreeSet::new();
+                let mut bset = Set::new();
                 for s in set {
                     bset.insert(Value::String(s.as_str().into()));
                 }
@@ -211,7 +211,7 @@ impl MetadataValue {
                 Value::Array(Rc::new(values))
             }
             MetadataValue::Map(ref map) => {
-                let mut obj = BTreeMap::new();
+                let mut obj = Object::new();
                 for (k, v) in map {
                     obj.insert(Value::String(k.as_str().into()), v.to_value());
                 }
@@ -257,7 +257,6 @@ mod metadata_serde {
 mod tests {
     use super::*;
     use crate::value::Value;
-    use alloc::collections::BTreeSet;
 
     /// Round-trip: Value → MetadataValue → Value must be equivalent for
     /// all lossless variants (strings, bools, integers, arrays, objects).
@@ -299,7 +298,7 @@ mod tests {
 
     #[test]
     fn round_trip_string_set() {
-        let mut set = BTreeSet::new();
+        let mut set = Set::new();
         set.insert(Value::String("a".into()));
         set.insert(Value::String("b".into()));
         let v = Value::Set(Rc::new(set));
@@ -326,7 +325,7 @@ mod tests {
 
     #[test]
     fn mixed_set_uses_list() {
-        let mut set = BTreeSet::new();
+        let mut set = Set::new();
         set.insert(Value::String("a".into()));
         set.insert(Value::from(1_i64));
         let v = Value::Set(Rc::new(set));

src/rvm/program/serialization/value.rs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-use alloc::collections::{BTreeMap, BTreeSet};
 use alloc::format;
 use alloc::string::String;
 use alloc::vec::Vec;
@@ -10,6 +9,7 @@ use serde::de::{self, EnumAccess, VariantAccess as _, Visitor};
 use serde::ser::{SerializeSeq as _, SerializeTuple as _};
 use serde::{Deserialize, Serialize};
 
+use crate::collections::{Object, Set};
 use crate::number::Number;
 use crate::value::Value;
 
@@ -117,7 +117,7 @@ impl<'a> Serialize for BinaryValueSlice<'a> {
     }
 }
 
-struct BinarySetRef<'a>(&'a BTreeSet<Value>);
+struct BinarySetRef<'a>(&'a Set);
 
 impl<'a> Serialize for BinarySetRef<'a> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -132,7 +132,7 @@ impl<'a> Serialize for BinarySetRef<'a> {
     }
 }
 
-struct BinaryObjectRef<'a>(&'a BTreeMap<Value, Value>);
+struct BinaryObjectRef<'a>(&'a Object);
 
 impl<'a> Serialize for BinaryObjectRef<'a> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -253,19 +253,19 @@ impl<'de> Visitor<'de> for BinaryValueVisitor {
             }
             (BinaryVariant::Set, variant) => {
                 let items: Vec<BinaryValue> = variant.newtype_variant()?;
-                let mut set = BTreeSet::new();
+                let mut set = Set::new();
                 for item in items {
                     set.insert(item.into_value());
                 }
-                Ok(BinaryValue(Value::from(set)))
+                Ok(BinaryValue(Value::Set(crate::Rc::new(set))))
             }
             (BinaryVariant::Object, variant) => {
                 let entries: Vec<(BinaryValue, BinaryValue)> = variant.newtype_variant()?;
-                let mut map = BTreeMap::new();
+                let mut map = Object::new();
                 for (key, value) in entries {
                     map.insert(key.into_value(), value.into_value());
                 }
-                Ok(BinaryValue(Value::from(map)))
+                Ok(BinaryValue(Value::Object(crate::Rc::new(map))))
             }
             (BinaryVariant::Undefined, variant) => {
                 variant.unit_variant()?;

src/rvm/vm/arithmetic.rs

@@ -6,8 +6,6 @@
 // Disable both to keep patterns consistent within this file.
 #![allow(clippy::pattern_type_mismatch, clippy::needless_borrowed_reference)]
 
-use alloc::collections::BTreeSet;
-
 use crate::number::Number;
 use crate::value::Value;
 
@@ -32,8 +30,8 @@ impl RegoVM {
         match (a, b) {
             (&Value::Number(ref x), &Value::Number(ref y)) => Ok(Value::from(x.sub(y)?)),
             (&Value::Set(ref left), &Value::Set(ref right)) => {
-                let diff: BTreeSet<Value> = left.difference(right).cloned().collect();
-                Ok(Value::from_set(diff))
+                let diff = left.difference(right);
+                Ok(diff.into_value())
             }
             _ => Err(VmError::InvalidSubtraction {
                 left: a.clone(),