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>

src/languages/rego/compiler/function_calls.rs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use super::{Compiler, CompilerError, Register, Result};
+use crate::ast::ExprRef;
+use crate::lexer::Span;
+use crate::rvm::instructions::{BuiltinCallParams, FunctionCallParams};
+use crate::rvm::Instruction;
+use crate::utils::get_path_string;
+use alloc::vec::Vec;
+
+impl<'a> Compiler<'a> {
+    pub(super) fn compile_function_call(
+        &mut self,
+        fcn: &ExprRef,
+        params: &[ExprRef],
+        span: Span,
+    ) -> Result<Register> {
+        let fcn_path =
+            get_path_string(fcn, None).map_err(|_| CompilerError::InvalidFunctionExpression)?;
+
+        let original_fcn_path = fcn_path.clone();
+        let full_fcn_path = if self.policy.inner.rules.contains_key(&fcn_path) {
+            fcn_path
+        } else {
+            get_path_string(fcn, Some(&self.current_package))
+                .map_err(|_| CompilerError::InvalidFunctionExpressionWithPackage)?
+        };
+
+        let mut arg_regs = Vec::new();
+        for param in params.iter() {
+            let param_reg = self.compile_rego_expr_with_span(param, param.span(), false)?;
+            arg_regs.push(param_reg);
+        }
+
+        let dest = self.alloc_register();
+
+        if self.is_user_defined_function(&full_fcn_path) {
+            let rule_index = self.get_or_assign_rule_index(&full_fcn_path)?;
+            let mut args_array = [0u8; 8];
+            let num_args = arg_regs.len().min(8) as u8;
+            for (i, &reg) in arg_regs.iter().take(8).enumerate() {
+                args_array[i] = reg;
+            }
+
+            let params_index = self.program.add_function_call_params(FunctionCallParams {
+                func_rule_index: rule_index,
+                dest,
+                num_args,
+                args: args_array,
+            });
+            self.emit_instruction(Instruction::FunctionCall { params_index }, &span);
+        } else if self.is_builtin(&original_fcn_path) {
+            let builtin_index = self.get_builtin_index(&original_fcn_path)?;
+            let mut args_array = [0u8; 8];
+            let num_args = arg_regs.len().min(8) as u8;
+            for (i, &reg) in arg_regs.iter().take(8).enumerate() {
+                args_array[i] = reg;
+            }
+
+            let params_index = self.program.add_builtin_call_params(BuiltinCallParams {
+                dest,
+                builtin_index,
+                num_args,
+                args: args_array,
+            });
+            self.emit_instruction(Instruction::BuiltinCall { params_index }, &span);
+        } else {
+            return Err(CompilerError::UnknownFunction {
+                name: original_fcn_path,
+            });
+        }
+
+        Ok(dest)
+    }
+}