Rename pipe-buffered to pipe-series

The `pipe-buffered` function has been renamed to `pipe-series` to better
reflect its functionality. This change involves updating the function
name in the example file `examples/data_stream_pipe_buffered.myc` and
across the Rust source code in `src/ast/rtl/streams.rs`. Additionally,
test cases and documentation have been updated accordingly.

tests/pipeline.rs

@@ -146,57 +146,57 @@ fn test_pipeline_optional_type() {
     }
 }
 
-/// Verifies that `pipe-buffered` accumulates values into Series and only fires
+/// Verifies that `pipe-series` accumulates values into Series and only fires
 /// the lambda once all series have reached the lookback depth (fill gate).
 /// Lambda parameters must be Series objects, not individual values.
 #[test]
-fn test_pipe_buffered_fill_gate() {
+fn test_pipe_series_fill_gate() {
     let env = Environment::new();
     // create-random-ohlc produces 10 ticks. With lookback 3, the lambda
     // fires from tick 3 onwards (8 times). Each call returns the difference
     // between the current and previous close: (.close (bars 0)) - (.close (bars 1))
     let source = "(do
         (def ohlc (create-random-ohlc 42 10))
-        (def result (pipe-buffered 3 [ohlc]
+        (def result (pipe-series 3 [ohlc]
             (fn [bars]
                 (- (.close (bars 0)) (.close (bars 1))))))
         result
     )";
     let res = env.run_script(source);
-    assert!(res.is_ok(), "pipe-buffered script failed: {:?}", res.err());
+    assert!(res.is_ok(), "pipe-series script failed: {:?}", res.err());
 
     let val = res.unwrap();
     if let Value::Stream(s) = val {
         assert_eq!(s.stream_type_name(), "stream");
     } else {
-        panic!("Expected Stream from pipe-buffered, got: {:?}", val);
+        panic!("Expected Stream from pipe-series, got: {:?}", val);
     }
 }
 
-/// Verifies that pipe-buffered with multiple inputs waits for all series to fill.
+/// Verifies that pipe-series with multiple inputs waits for all series to fill.
 #[test]
-fn test_pipe_buffered_multi_input() {
+fn test_pipe_series_multi_input() {
     let env = Environment::new();
     let source = "(do
         (def src1 (create-random-ohlc 42 10))
         (def src2 (create-random-ohlc 99 10))
-        (def result (pipe-buffered 2 [src1 src2]
+        (def result (pipe-series 2 [src1 src2]
             (fn [a b]
                 (+ (.close (a 0)) (.close (b 0))))))
         result
     )";
     let res = env.run_script(source);
-    assert!(res.is_ok(), "pipe-buffered multi-input failed: {:?}", res.err());
+    assert!(res.is_ok(), "pipe-series multi-input failed: {:?}", res.err());
 }
 
-/// Verifies that pipe-buffered lambda params are typed as Series, not raw values.
+/// Verifies that pipe-series lambda params are typed as Series, not raw values.
 /// The arg hint resolver must wrap inner types in Series<T>.
 #[test]
-fn test_pipe_buffered_lambda_params_are_series() {
+fn test_pipe_series_lambda_params_are_series() {
     let env = Environment::new();
     let source = "(do
         (def ohlc (create-random-ohlc 42 5))
-        (pipe-buffered 3 [ohlc] (fn [bars] (.close (bars 0))))
+        (pipe-series 3 [ohlc] (fn [bars] (.close (bars 0))))
     )";
     let dump = env.dump_ast(source).expect("dump_ast failed");