Add RSolve, fix Expand/Together/Simplify/Apart, improve parser and pattern matching

- Add RSolve for linear recurrence relations with constant coefficients
- Fix Expand for fraction^n and product^n distribution
- Rewrite Together to use LCM-based common denominator computation
- Fix Simplify to thread over Lists
- Extend Apart for partial fraction decomposition improvements
- Fix ReplaceAll to handle list-of-rule-lists (expr /. {{r1}, {r2}})
- Fix denominator parenthesization in display formatting
- Add tilde infix notation (~f~) and parser improvements
- Add ExpIntegralEi series expansion and numerical evaluation
- Add cyclotomic polynomial detection in Solve
- Extend arithmetic with Mod, PowerMod, and integer operations

Author: ad-si

src/evaluator/dispatch/calculus_functions.rs

@@ -65,9 +65,12 @@ pub fn dispatch_calculus_functions(
     "Limit" if (2..=3).contains(&args.len()) => {
       return Some(crate::functions::calculus_ast::limit_ast(args));
     }
-    "Series" if args.len() == 2 => {
+    "Series" if args.len() >= 2 => {
       return Some(crate::functions::calculus_ast::series_ast(args));
     }
+    "RSolve" if args.len() == 3 => {
+      return Some(crate::functions::rsolve_ast::rsolve_ast(args));
+    }
     "DSolve" if args.len() == 3 => {
       return Some(crate::functions::ode_ast::dsolve_ast(args));
     }

src/evaluator/pattern_matching.rs

@@ -990,6 +990,21 @@ pub fn apply_replace_all_ast(
       replacement,
     } => (expr_to_string(pattern), expr_to_string(replacement)),
     Expr::List(items) if !items.is_empty() => {
+      // Check if this is a list of rule-lists: {{x->1}, {x->2}}
+      // In Wolfram, expr /. {{r1}, {r2}} applies each sub-list independently
+      // and returns a list of results: {expr/.{r1}, expr/.{r2}}
+      let is_list_of_rule_lists = items.iter().all(|item| {
+        matches!(item, Expr::List(sub) if sub.iter().all(|r|
+          matches!(r, Expr::Rule { .. } | Expr::RuleDelayed { .. })
+        ))
+      });
+      if is_list_of_rule_lists {
+        let results: Result<Vec<Expr>, _> = items
+          .iter()
+          .map(|sub_rules| apply_replace_all_ast(expr, sub_rules))
+          .collect();
+        return results.map(Expr::List);
+      }
       // Multiple rules - apply at AST level for correctness and performance.
       // Collect (pattern_expr, replacement_expr) pairs.
       let rule_exprs: Vec<(&Expr, &Expr)> = items