fix: has_many with limit and sort not respected in exists query filters

Previously, the relationship limit was not being applied when using the relationship
in an `exists` query. After fixing that, then the limit was being applied in the
wrong place - it needs to be *inside* the exists check pre-filtering, instead
of outside it.

The test for this feature is in AshPostgres ash-project/ash_postgres#667 -
this code makes that test pass.

Author: sevenseacat

lib/expr.ex

@@ -2373,7 +2373,7 @@ defmodule AshSql.Expr do
       AshSql.Join.related_subquery(first_relationship, query,
         filter: filter,
         filter_subquery?: true,
-        sort?: Map.get(first_relationship, :from_many?),
+        sort?: Map.get(first_relationship, :from_many?) || not is_nil(first_relationship.sort),
         start_bindings_at: 1,
         select_star?: !Map.get(first_relationship, :manual),
         in_group?: true,

lib/join.ex

@@ -428,7 +428,8 @@ defmodule AshSql.Join do
     |> Ash.Query.set_context(relationship.context)
     |> Ash.Query.do_filter(relationship.filter, parent_stack: parent_resources)
     |> then(fn query ->
-      if Map.get(relationship, :from_many?) && filter_subquery? do
+      if (Map.get(relationship, :from_many?) || not is_nil(Map.get(relationship, :limit))) &&
+           filter_subquery? do
         query
       else
         Ash.Query.do_filter(query, filter, parent_stack: parent_resources)
@@ -576,6 +577,48 @@ defmodule AshSql.Join do
     end
   end
 
+  defp limit_from_many(
+         query,
+         %{limit: limit, destination: destination},
+         filter,
+         filter_subquery?,
+         opts
+       )
+       when is_integer(limit) do
+    # Check if query has parent expressions - if so, we can't wrap in a non-lateral subquery
+    # because parent references won't resolve across the subquery boundary
+    has_parent_expr? = !!query.__ash_bindings__.context[:data_layer][:has_parent_expr?]
+
+    if filter_subquery? && !has_parent_expr? do
+      # Wrap the limited query in a subquery, then apply filter on top
+      query =
+        from(row in Ecto.Query.subquery(from(row in query, limit: ^limit)),
+          as: ^query.__ash_bindings__.root_binding
+        )
+        |> Map.put(:__ash_bindings__, query.__ash_bindings__)
+        |> AshSql.Bindings.default_bindings(
+          destination,
+          query.__ash_bindings__.sql_behaviour
+        )
+
+      {:ok, query} = AshSql.Filter.filter(query, filter, query.__ash_bindings__.resource)
+
+      if opts[:select_star?] do
+        from(row in Ecto.Query.exclude(query, :select), select: 1)
+      else
+        query
+      end
+    else
+      # When has_parent_expr?, we can't apply the limit in exists subquery
+      # Fall through to the default clause which just applies select_star if needed
+      if opts[:select_star?] do
+        from(row in Ecto.Query.exclude(query, :select), select: 1)
+      else
+        query
+      end
+    end
+  end
+
   defp limit_from_many(query, _, _, _, opts) do
     if opts[:select_star?] do
       from(row in Ecto.Query.exclude(query, :select), select: 1)