feat!: root-inheriting predicate combinators; fix docs naming nonexistent methods

[zantvoort]

Closes the documentation and error-message drift reported in #406, and completes the #372 join-widening model at the predicate level, which that report surfaced.

Docs and error messages

• The collection-parameter error in TemplateProcessor now points at real API, whereId(ids) or where(path, IN, values), instead of the nonexistent whereAny/whereAll builder methods.
• The phantom whereAny convention in the WhereBuilder class docs is replaced with the join-widening model. This also existed in the storm-java21 variant, which the issue did not list, and is fixed there as well.
• The Kotlin KDoc examples now use whereBuilder { } and the resultList property instead of the Java-only where-lambda and getResultList(), and compile as written against the current API.
• Copy-pasted javadoc corrected: DbTable specifies the table or view name (optionally its schema), DbColumn the column name, and EQUALS/NOT_EQUALS are labeled =/<> rather than EXISTS/NOT EXISTS.
• The null guard in Operator moves from the display name, which is never null, to the column parameter via a requireColumn helper in every built-in operator. A null column now throws IllegalArgumentException instead of silently rendering null = ?. The zero-placeholder IN/NOT_IN forms never reference the column and still render their constant expressions.

Predicate combinators inherit the query root

andAny/orAny were the predicate-level Any variants #372 left behind; writing docs that pointed users at them made that visible. They are removed from every API, and and/or follow the clause model: the query root decides what combines.

• Java (storm-java21): every predicate carries the builder's root, so and/or absorb the Any twins with a ? extends T parameter. A narrow builder combines within the root graph; a join widens the root. Post-feat!: a join widens the query, replacing the Any clause variants #372 the twins had no constructible argument with a foreign root left.
• Kotlin: and/or move into the whereBuilder { } scope as member extensions bound to the scope's root. A narrow scope combines within the root graph; a join widens the root, and the same expression combines predicates across joined entities, e.g. (petName eq "Leo") and (ownerLastName eq "Davis") after joining Owner. Top-level and/or extensions combine same-rooted predicates outside a scope. A new integration test covers the cross-entity case after a join.
• Core states the same root-relative contract: and/or take ? extends T, the level where operates at. The bridges present their arguments within the receiver's root, which holds in every sound path: narrow scopes guarantee same-root by their public signatures, and a widened scope's root is Data itself. Query-time validation reports paths on entities outside the query.

Verified with full builds of storm-foundation, storm-core (2603 tests), storm-java21 (541) and storm-kotlin (1714, including the new cross-entity test) on JDK 21, plus a full reactor compile.

Fixes #406

[codecov]

Codecov Report

❌ Patch coverage is 92.85714% with 2 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
...a/st/orm/core/template/impl/TemplateProcessor.java	0.00%	2 Missing ⚠️

📢 Thoughts on this report? Let us know!