fix: reinforce teeing and reduce classification guidance

Author: martinfrancois

skills/java-streams/SKILL.md

@@ -39,6 +39,7 @@ are equivalent.
    - concatenated text: `Collectors.joining`;
    - numeric primitive result: `mapToInt`/`mapToLong`/`mapToDouble` plus primitive stream terminal
      operations;
+   - two independent aggregates over the same input on Java 12+: `Collectors.teeing`;
    - grouping/indexing: `groupingBy`, downstream collectors, `partitioningBy`, or `toMap` with
      explicit merge/null handling.
 2. Prefer stream terminal operations that encode intent directly: `anyMatch` for existence, `count`
@@ -48,8 +49,8 @@ are equivalent.
    `flatMap(Optional::stream)` on Java 9+ for `Stream<Optional<T>>`. On Java 16+, consider
    `mapMulti` only when it makes a small zero-or-one/one-to-few transformation clearer or avoids
    many tiny stream allocations.
-4. Use primitive streams for primitive aggregation. Keep `reduce(identity, op)` for immutable
-   non-primitive accumulation such as `BigDecimal`.
+4. Use primitive streams for primitive aggregation. Keep and explicitly classify `reduce(identity,
+   op)` as acceptable for immutable non-primitive accumulation such as `BigDecimal`.
 5. Choose collectors by result semantics, and state duplicate-key/null contracts explicitly. When a
    later step needs an expensive check result, carry `element + result` with a baseline-compatible
    holder; use `Map.entry` only on Java 9+ when both values are non-null.

skills/java-streams/references/hard-stops.md

@@ -21,6 +21,8 @@ Fix these before finalizing:
 - `map(...).collect(toList())` followed immediately by `String.join`. Use `Collectors.joining`.
 - Boxed numeric `reduce` for primitive totals/statistics. Use primitive streams or summarizing
   collectors unless the type is genuinely non-primitive, such as `BigDecimal`.
+  In audits, explicitly classify non-primitive reductions such as
+  `reduce(BigDecimal.ZERO, BigDecimal::add)` as acceptable.
 - Nested `map(... stream ... collect(...)).flatMap(...)` where a direct `flatMap` pipeline is
   clearer.
 - `filter(Optional::isPresent).map(Optional::get)` on Java 9+. Use `flatMap(Optional::stream)`.

skills/java-streams/references/stream-examples.md

@@ -209,3 +209,14 @@ List<Product> favoriteProducts = user.getFavoriteProducts().stream()
 `Map.entry` is appropriate in this example because the baseline is Java 24 and neither side of the
 entry is null. If nulls can reach the carrier or the baseline is Java 8, use a null-tolerant project
 type or `AbstractMap.SimpleImmutableEntry`.
+
+Use Java 12+ `Collectors.teeing` when two independent aggregates should be computed over the same
+input:
+
+```java
+Pair<Product, Product> range = products.stream()
+        .collect(Collectors.teeing(
+                Collectors.minBy(Comparator.comparing(Product::price)),
+                Collectors.maxBy(Comparator.comparing(Product::price)),
+                (min, max) -> new Pair<>(min.orElse(null), max.orElse(null))));
+```