[SPARK-52869][SQL] Add FrameLessOffsetWindowFunction validation to validateResolvedWindowExpression for reuse in single-pass analyzer

### What changes were proposed in this pull request?

A check if `FrameLessOffsetWindowFunction` is compatible with its frame (it has to be ordered and can't be a `SpecifiedWindowFrame` other than an ordered frame) is added to `WindowResolver.validateResolvedWindowExpression`.

### Why are the changes needed?

The same repeating logic is required both in the fixed-point and single-pass analyzer implementations.

### Does this PR introduce _any_ user-facing change?

No.

### How was this patch tested?

Using existing unit tests.

### Was this patch authored or co-authored using generative AI tooling?

No.

Closes #51559 from nikola-jovicevic-db/SPARK-52869.

Authored-by: Nikola Jovićević <[email protected]>
Signed-off-by: Wenchen Fan <[email protected]>

Author: nikola-jovicevic-db

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/CheckAnalysis.scala

@@ -437,15 +437,6 @@ trait CheckAnalysis extends LookupCatalog with QueryErrorsBase with PlanToString
               errorClass = "WINDOW_FUNCTION_WITHOUT_OVER_CLAUSE",
               messageParameters = Map("funcName" -> toSQLExpr(w)))
 
-          case w @ WindowExpression(wf: FrameLessOffsetWindowFunction,
-            WindowSpecDefinition(_, order, frame: SpecifiedWindowFrame))
-             if order.isEmpty || !frame.isOffset =>
-            w.failAnalysis(
-              errorClass = "WINDOW_FUNCTION_AND_FRAME_MISMATCH",
-              messageParameters = Map(
-                "funcName" -> toSQLExpr(wf),
-                "windowExpr" -> toSQLExpr(w)))
-
           case agg @ AggregateExpression(listAgg: ListAgg, _, _, _, _)
             if agg.isDistinct && listAgg.needSaveOrderValue =>
             throw QueryCompilationErrors.functionAndOrderExpressionMismatchError(

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/WindowResolution.scala

@@ -107,15 +107,40 @@ object WindowResolution {
    *
    * By checking the type and configuration of [[WindowExpression.windowFunction]] it enforces the
    * following rules:
+   * - Disallows [[FrameLessOffsetWindowFunction]] (e.g. [[Lag]]) without defined ordering or
+   *   one with a frame which is defined as something other than an offset frame (e.g.
+   *   `ROWS BETWEEN` is logically incompatible with offset functions).
    * - Disallows distinct aggregate expressions in window functions.
-   * - Disallows use of certain aggregate functions - [[ListaAgg]], [[PercentileCont]],
+   * - Disallows use of certain aggregate functions - [[ListAgg]], [[PercentileCont]],
    *   [[PercentileDisc]], [[Median]]
    * - Allows only window functions of following types:
    *   - [[AggregateExpression]] (non-distinct)
    *   - [[FrameLessOffsetWindowFunction]]
    *   - [[AggregateWindowFunction]]
    */
   def validateResolvedWindowExpression(windowExpression: WindowExpression): Unit = {
+    checkWindowFunctionAndFrameMismatch(windowExpression)
+    checkWindowFunction(windowExpression)
+  }
+
+  def checkWindowFunctionAndFrameMismatch(windowExpression: WindowExpression): Unit = {
+    windowExpression match {
+      case _ @ WindowExpression(
+      windowFunction: FrameLessOffsetWindowFunction,
+      WindowSpecDefinition(_, order, frame: SpecifiedWindowFrame)
+      ) if order.isEmpty || !frame.isOffset =>
+        windowExpression.failAnalysis(
+          errorClass = "WINDOW_FUNCTION_AND_FRAME_MISMATCH",
+          messageParameters = Map(
+            "funcName" -> toSQLExpr(windowFunction),
+            "windowExpr" -> toSQLExpr(windowExpression)
+          )
+        )
+      case _ =>
+    }
+  }
+
+  def checkWindowFunction(windowExpression: WindowExpression): Unit = {
     windowExpression.windowFunction match {
       case AggregateExpression(_, _, true, _, _) =>
         windowExpression.failAnalysis(