js-rigor: reliability flows through every rule kind; multi_hop value collection fixed

Systemic reliability gap found by the probe sweep: the compiled evaluation
paths never emitted the reliability the engine computes.

- Compiled _evaluateDirect omitted the relation's reliability, and the
  chain/multi_hop rules hardcoded reliability: 1.0 — so check() results
  reported 1.0 for any rule whose decision came through a chain, multi_hop,
  union, intersection, exclusion, or defeasible combination.
- The chain and multi_hop traversals now track per-path reliability (product
  of edge reliabilities) and report the winning path's value; the compiled
  and fallback logical operators (union/intersection/exclusion, direct_list
  fast path, early exits) report the selected child's reliability
  (max/min child or OWA trace index; exclusion multiplies both legs), and
  normal-mode defeasible combines base x requires x defeater reliabilities.
- The checker's logical fast path dropped collectedValues from union/
  intersection/exclusion results; it now passes them through.
- MultiHopRule.valueManager was read off relationManager where the real
  arbiter keeps it on the arbiter — collectValues: true on a multi_hop rule
  with a value-carrying edge crashed the evaluation (error result, silent
  denial). Now resolved at the arbiter level with a relationManager
  fallback for stubs.

Campaign pins: reliability per kind (chain/multi_hop product, union/intersection
selected child, exclusion/defeasible product), and multi_hop value collection
through persistent and partial contexts.

src/authorization/rules/ChainRule.js

@@ -239,13 +239,16 @@ export class ChainRule extends BaseRule {
 
             // Deduplicate: keep best path per node
             const existing = pathMap.get(nextId);
-            if (existing && existing.possibility >= nextPossibility) continue;
+            const nextReliability = (currentPath.reliability ?? 1.0) * (rel.reliability ?? 1.0);
+            if (existing && existing.possibility > nextPossibility) continue;
+            if (existing && existing.possibility === nextPossibility && (existing.reliability ?? 1.0) >= nextReliability) continue;
 
             // Create extended path
             const extendedPath = {
               id: nextId,
               key: nextKey,
               possibility: nextPossibility,
+              reliability: nextReliability,
               path: [...currentPath.path, nextKey],
               pathEntities: [...currentPath.pathEntities, { id: nextId, key: nextKey, source: rel.source || 'persistent' }]
             };
@@ -269,10 +272,18 @@ export class ChainRule extends BaseRule {
     const targetId = reverse ? userIdNum : objectIdNum;
     const targetPaths = currentPaths.filter(path => path.id === targetId);
     let finalPossibility = 0;
+    let finalReliability = 1.0;
     
     if (targetPaths.length > 0) {
-      // Use MAX across paths (disjunctive)
-      finalPossibility = Math.max(...targetPaths.map(path => path.possibility));
+      // Use MAX across paths (disjunctive); the winning path's reliability
+      // is the product of its edges' reliabilities (MIN along the chain).
+      const best = targetPaths.reduce((a, b) =>
+        (b.possibility > a.possibility ||
+         (b.possibility === a.possibility && (b.reliability ?? 1.0) > (a.reliability ?? 1.0)))
+          ? b : a
+      );
+      finalPossibility = best.possibility;
+      finalReliability = best.reliability ?? 1.0;
     }
 
     if (fastPath && finalPossibility < minPossibility) {
@@ -338,7 +349,7 @@ export class ChainRule extends BaseRule {
     // Build authorization result with single possibility value
     const authResult = {
       possibility: finalPossibility,
-      reliability: 1.0,
+      reliability: finalReliability,
       ...(includeMeta && {
         meta: finalPossibility > 0 ? {
           ruleType: 'chain',