Reimplement driver tests for PGAdvisoryXactLock so they don't involve clock timing

I've gotten a failure a couple times in the driver tests for
`PGAdvisoryXactLock` in that it times out when trying to use another
transaction to acquire or release the lock:

    --- FAIL: TestDriverDatabaseSQLLibPQ (19.44s)
        driver_test.go:40: Generated schema "river_2025_05_08t01_05_22_schema_08" with migrations [1 2 3 4 5 6] on line "main" in 53.591381ms [9 generated] [5 reused]
        driver_test.go:40: Driver does not support listener; skipping listener tests
        --- FAIL: TestDriverDatabaseSQLLibPQ/PGAdvisoryXactLock (0.21s)
            riverdrivertest.go:2691: TestTx using schema: river_2025_05_08t01_05_22_schema_06
            riverdrivertest.go:2701: TestTx using schema: river_2025_05_08t01_05_22_schema_06
            riverdrivertest.go:2727:
                    Error Trace:	/home/runner/work/river/river/internal/riverinternaltest/riverdrivertest/riverdrivertest.go:2727
                    Error:      	Goroutine didn't finish in a timely manner
                    Test:       	TestDriverDatabaseSQLLibPQ/PGAdvisoryXactLock
        riverdbtest.go:277: Checked in schema "river_2025_05_08t01_05_22_schema_08"; 1 idle schema(s) [137 generated] [133 reused]
    FAIL
    FAIL	github.com/riverqueue/river	27.844s

Here, reimplement this test wholesale, moving away from dependency on
clock timing and over to having the other test transaction use the
non-blocking `pg_try_advisory_lock `instead. This should eliminate all
intermittency from this test case.

[1] https://github.com/riverqueue/river/actions/runs/14896356386/job/41839541488

Author: brandur

internal/riverinternaltest/riverdrivertest/riverdrivertest.go

@@ -23,6 +23,7 @@ import (
 	"github.com/riverqueue/river/internal/rivercommon"
 	"github.com/riverqueue/river/riverdriver"
 	"github.com/riverqueue/river/rivershared/testfactory"
+	"github.com/riverqueue/river/rivershared/util/hashutil"
 	"github.com/riverqueue/river/rivershared/util/ptrutil"
 	"github.com/riverqueue/river/rivershared/util/sliceutil"
 	"github.com/riverqueue/river/rivertype"
@@ -2703,43 +2704,43 @@ func Exercise[TTx any](ctx context.Context, t *testing.T,
 
 		exec, _ := setup(ctx, t)
 
-		// Acquire the advisory lock.
-		_, err := exec.PGAdvisoryXactLock(ctx, 123456)
-		require.NoError(t, err)
-
-		// Open a new transaction and try to acquire the same lock, which should
-		// block because the lock can't be acquired. Verify some amount of wait,
-		// cancel the lock acquisition attempt, then verify return.
-		{
-			otherExec := executorWithTx(ctx, t)
-
-			goroutineDone := make(chan struct{})
+		// It's possible for multiple versions of this test to be running at the
+		// same time (from different drivers), so make sure the lock we're
+		// acquiring per test is unique by using the complete test name.
+		lockHash := hashutil.NewAdvisoryLockHash(0)
+		lockHash.Write([]byte(t.Name()))
+		lockHash.Write([]byte("123456"))
+		key := lockHash.Key()
+
+		// Tries to acquire the given lock from another test transaction and
+		// returns true if the lock was acquired.
+		tryAcquireLock := func(exec riverdriver.Executor) bool {
+			var lockAcquired bool
+			require.NoError(t, exec.QueryRow(ctx, "SELECT pg_try_advisory_lock($1)", key).Scan(&lockAcquired))
+			return lockAcquired
+		}
 
-			ctx, cancel := context.WithCancel(ctx)
-			t.Cleanup(cancel)
+		// Start a transaction to acquire the lock so we can later release the
+		// lock by rolling back.
+		execTx, err := exec.Begin(ctx)
+		require.NoError(t, err)
 
-			go func() {
-				defer close(goroutineDone)
+		// Acquire the advisory lock on the main test transaction.
+		_, err = execTx.PGAdvisoryXactLock(ctx, key)
+		require.NoError(t, err)
 
-				_, err := otherExec.PGAdvisoryXactLock(ctx, 123456)
-				// pgx will produce a context.Canceled error, but pg swallows it to emit its own
-				require.Regexp(t, "(context canceled|pq: canceling statement due to user request)", err.Error())
-			}()
+		// Start another test transaction unrelated to the first.
+		otherExec := executorWithTx(ctx, t)
 
-			select {
-			case <-goroutineDone:
-				require.FailNow(t, "Unexpectedly acquired lock that should've held by other transaction")
-			case <-time.After(50 * time.Millisecond):
-			}
+		// The other test transaction is unable to acquire the lock because the
+		// first test transaction holds it.
+		require.False(t, tryAcquireLock(otherExec))
 
-			cancel()
+		// Roll back the first test transaction to release the lock.
+		require.NoError(t, execTx.Rollback(ctx))
 
-			select {
-			case <-goroutineDone:
-			case <-time.After(50 * time.Millisecond):
-				require.FailNow(t, "Goroutine didn't finish in a timely manner")
-			}
-		}
+		// The other test transaction can now acquire the lock.
+		require.True(t, tryAcquireLock(otherExec))
 	})
 
 	t.Run("QueueCreateOrSetUpdatedAt", func(t *testing.T) {