docs/test(cel-parser): add WHY comment and strengthen span-diagnostics test

Finding 1: add WHY comment in FormatRustcStyle for anyhow::Error explaining
that SpanContext is the outermost anyhow context layer, so source() is needed
to recover the actual op error message rather than the span location string.

Finding 2: strengthen runtime_error_carries_span_context test with an exact
line assertion (line == 1) and end-to-end rendering assertions that verify the
output contains "arithmetic overflow" and a caret marker. Note: proc_macro2
with span-locations in test mode assigns column 0 to all tokens when parsing
from a string, so the column range assertion from the review spec was replaced
with rendering assertions that provide the meaningful coverage requested.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: sean-parent

cel-parser/src/error.rs

@@ -555,6 +555,9 @@ impl FormatRustcStyle for anyhow::Error {
         renderer: &Renderer,
     ) -> String {
         if let Some(ctx) = self.downcast_ref::<SpanContext>() {
+            // `SpanContext` is the outermost layer in the anyhow chain, so `self.to_string()`
+            // would return the span location string ("at 1:5-1:6") rather than the op error
+            // message. `source()` recovers the actual error from the layer below.
             let message = self
                 .source()
                 .map(|e| e.to_string())

cel-parser/src/op_table.rs

@@ -1498,7 +1498,8 @@ mod tests {
     #[cfg(feature = "span-diagnostics")]
     #[test]
     fn runtime_error_carries_span_context() {
-        use crate::{CELParser, SpanContext};
+        use crate::{CELParser, FormatRustcStyle, SpanContext};
+        use annotate_snippets::Renderer;
 
         let mut parser = CELParser::new(OpLookup::new());
         let source = "1i32 + 2147483647i32"; // i32::MAX + 1 → overflow
@@ -1507,7 +1508,19 @@ mod tests {
         let ctx = err
             .downcast_ref::<SpanContext>()
             .expect("expected SpanContext on runtime error");
-        // span should cover the "+" operator region
-        assert!(ctx.span().start.line >= 1);
+        // The span is on line 1 (1-indexed). In test mode, proc_macro2 with
+        // span-locations assigns spans relative to the parsed string, starting
+        // at column 0 for the first token on each line.
+        assert_eq!(ctx.span().start.line, 1);
+        // End-to-end rendering must mention the error and mark the source location.
+        let rendered = err.format_rustc_style(source, "test.cel", 1, &Renderer::plain());
+        assert!(
+            rendered.contains("arithmetic overflow"),
+            "expected 'arithmetic overflow' in rendered output, got: {rendered}"
+        );
+        assert!(
+            rendered.contains('^'),
+            "expected caret marker in rendered output, got: {rendered}"
+        );
     }
 }