feat!: Rego -> RVM Compiler and extensive testsuite (#506)

# RVM compiler test cases

Coverage:
- arithmetic
- arrays
- chained lookups
- comparisons
- comprehensions
- default rules
- destructuring
- function rules
- loops/quantifiers
- multiple entrypoints
- objects/sets
- variables
- negative/edge scenarios such as data/rule conflicts
- virtual data lookups
- etc

 # Modify interpreter and compiled policy for RVM Compilation

- Interpreter::eval_default_rule_for_compiler:
   evaluates a named default rule in isolation - allows compiler to emit a constant value instead of instructions
   for the default value

#  feat: Rego Compiler Scaffolding

- Introduce the rego::compiler module surface and entry point wiring
- Add the core compiler concepts:
  - register allocator
  - scope tracking
  - literal/builtin tables
  - rule worklists
  - instruction emit helpers
  - compiler-specific error types
  - context structs for rules, comprehensions, and loops to support later lowering passes.

# feat: Compile Rules/Queries

- add compiler::compile_from_policy workflow plus rule worklist, entry-point wiring, and recursion checks
- implement query lowering:
  - scheduling-aware statement ordering
  - loop hoisting
  - “every/some” semantics
  - context yields
  -  literal assertions
- finalize Program construction

# feat: Expression Lowering

- add compile_rego_expr and helpers to translate every AST expression into RVM instructions,
- interop with binding plans, comprehensions, and membership checks.
- implement collection literal builders (ArrayCreate, SetCreate, ObjectCreate)
  - dedupe literal keys and handle mixed literal/dynamic fields via instruction data blocks.
- operations:
  - arithmetic/boolean/bin operators
  - membership
  - unary minus
  - set unions/intersections
  - etc
- user-defined and builtin function calls
- reference handling
  - analyse chained refs
  - distinguishe data/input/local roots
  - perform rule dispatch or virtual document lookups
  - emits optimized Index/ChainedIndex instructions.

# feat: Comprehensions & Loops

- shared comprehension emitter
 - wraps array/set/object comprehensions with ComprehensionBegin/End
 - context management
- loop lowering utilities
 - read hoisting metadata
 - emit LoopStart/LoopNext
 - some in lowering
 - every quantifiers
 - index iteration
 - propagate binding plans into stored registers so downstream statements see bound variables.

# feat: Destructuring Lowering

- destructuring planner integration
 - assignment/parameter/loop bindings use hoisted plans instead of re-walking ASTs.
- handle :=, =, wildcard matches, and equality
 - evaluate RHS
 - applying destructuring plans
 - emit assert condition as needed
- support nested array/object destructuring, dynamic keys, and some ... in forms

# test: Shared Testing + RVM Suites

- move YAML test helpers into test_utils.rs and re-export via common.rs for use by interpreter and vm test suites
- comprehensive compiler test suite
  - compiles policies with the new Rego→RVM compiler
  - runs them through RegoVM
  - compares against interpreter behavior
  - supports multiple entry points
  - provides assembly listings
  - filterable YAML suites.

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>

tests/rvm/rego/cases/objects.yaml

@@ -0,0 +1,108 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+# Objects Test Suite
+# Tests object creation, nested objects, field access, and dynamic field operations
+
+cases:
+  - note: object_creation
+    data: {}
+    modules:
+      - |
+        package test
+        main := result if {
+          result := {"name": "Alice", "age": 30, "active": true}
+        }
+    query: data.test.main
+    want_result: {"name": "Alice", "age": 30, "active": true}
+
+  - note: nested_objects
+    data: {}
+    modules:
+      - |
+        package test
+        main := result if {
+          result := {
+            "user": {
+              "name": "Alice", 
+              "details": {"age": 30, "active": true}
+            },
+            "config": {"debug": false}
+          }
+        }
+    query: data.test.main
+    want_result: {"user": {"name": "Alice", "details": {"age": 30, "active": true}}, "config": {"debug": false}}
+
+  - note: object_field_access
+    data: {}
+    modules:
+      - |
+        package test
+        user := {"name": "Alice", "age": 30}
+        main := result if {
+          result := user.name
+        }
+    query: data.test.main
+    want_result: "Alice"
+
+  - note: nested_object_access
+    data: {}
+    modules:
+      - |
+        package test
+        user := {
+          "name": "Alice", 
+          "details": {
+            "age": 30, 
+            "profile": {
+              "country": "USA",
+              "city": "Seattle"
+            }
+          }
+        }
+        main := result if {
+          result := user.details.profile.city
+        }
+    query: data.test.main
+    want_result: "Seattle"
+
+  - note: dynamic_field_name_get
+    data: {}
+    modules:
+      - |
+        package test
+        user := {"name": "Alice", "age": 30, "status": "active"}
+        field_name := "status"
+        main := result if {
+          result := user[field_name]
+        }
+    query: data.test.main
+    want_result: "active"
+
+  - note: dynamic_field_name_set
+    data: {}
+    modules:
+      - |
+        package test
+        field_name := "email"
+        field_value := "alice@example.com"
+        main := result if {
+          result := {field_name: field_value, "name": "Alice"}
+        }
+    query: data.test.main
+    want_result: {"email": "alice@example.com", "name": "Alice"}
+
+  - note: dynamic_object_construction
+    data: {}
+    modules:
+      - |
+        package test
+        name_field := "username"
+        name_value := "alice123"
+        age_field := "user_age" 
+        age_value := 25
+        main := result if {
+          result := {name_field: name_value, age_field: age_value}
+        }
+    query: data.test.main
+    want_result: {"username": "alice123", "user_age": 25}