Respect concurrency limits when releasing claimed executions during shutdown

When a worker gracefully shuts down, claimed executions are released back
to ready state via ClaimedExecution#release. Previously, this always used
dispatch_bypassing_concurrency_limits, which ignored whether another job
with the same concurrency key was already running.

This could cause duplicate concurrent executions in the following scenario:
1. Job A starts running with concurrency key "X" (semaphore value = 0)
2. Time passes, semaphore expires and is deleted
3. Job B with same key "X" enqueues, creates new semaphore, starts running
4. Worker running Job A receives shutdown signal
5. Job A is released via dispatch_bypassing_concurrency_limits
6. Job A goes to ready state, gets picked up by another worker
7. Both Job A and Job B now running concurrently (violates limit!)

Fix: Before releasing a job, check if any other jobs with the same
concurrency key are currently executing. If so, go through normal dispatch
which respects the concurrency policy (block or discard). If not, continue
to bypass limits for performance.

This ensures that graceful shutdown doesn't violate concurrency guarantees,
even when semaphores have expired during long-running job execution.

Author: mhenrixon

app/models/solid_queue/claimed_execution.rb

@@ -78,7 +78,13 @@ def perform
   def release
     SolidQueue.instrument(:release_claimed, job_id: job.id, process_id: process_id) do
       transaction do
-        job.dispatch_bypassing_concurrency_limits
+        if other_executions_holding_concurrency_lock?
+          # Another job with same concurrency key is already running.
+          # Go through normal dispatch which respects concurrency limits.
+          job.dispatch
+        else
+          job.dispatch_bypassing_concurrency_limits
+        end
         destroy!
       end
     end
@@ -113,4 +119,13 @@ def finished
         destroy!
       end
     end
+
+    def other_executions_holding_concurrency_lock?
+      return false unless job.concurrency_limited?
+
+      SolidQueue::Job.joins(:claimed_execution)
+        .where(concurrency_key: job.concurrency_key)
+        .where.not(id: job.id)
+        .exists?
+    end
 end

test/models/solid_queue/claimed_execution_test.rb

@@ -62,6 +62,24 @@ class SolidQueue::ClaimedExecutionTest < ActiveSupport::TestCase
     assert job.reload.ready?
   end
 
+  test "release bypasses concurrency limits when no other job with same key is executing" do
+    job_result = JobResult.create!(queue_name: "default", status: "")
+
+    # Create Job A with concurrency limit and claim it
+    job_a = DiscardableUpdateResultJob.perform_later(job_result, name: "A")
+    solid_queue_job_a = SolidQueue::Job.find_by(active_job_id: job_a.job_id)
+    SolidQueue::ReadyExecution.claim(solid_queue_job_a.queue_name, 1, @process.id)
+    claimed_execution_a = SolidQueue::ClaimedExecution.find_by(job_id: solid_queue_job_a.id)
+    assert claimed_execution_a
+
+    # Release job A - no other job with same key is running, so it should go to ready
+    assert_difference -> { SolidQueue::ClaimedExecution.count } => -1, -> { SolidQueue::ReadyExecution.count } => 1 do
+      claimed_execution_a.release
+    end
+
+    assert solid_queue_job_a.reload.ready?
+  end
+
   test "fail with error" do
     claimed_execution = prepare_and_claim_job AddToBufferJob.perform_later(42)
     job = claimed_execution.job