Refactor tests for better isolation

[simolus3]

This refactors our tests opening databases (DatabaseTest and SyncIntegrationTest) to:

1. No longer use GlobalScope when opening databases. Instead, we use the test scope we receive from runTest. Thanks to structured concurrency, this ensures that no async database code can "leak" out of the test.
2. Generate a random file name for each test, ensuring that two different tests won't interfere with each other.
3. In some places, start using the assertions library from Kotest instead of kotlin-test. These assertions are more expressive and lead to much better error messages (e.g. list shouldHaveSize 3 will actually print contents of the list on violations, assertEquals(3, list.size) is much less helpful).

The first step required some other changes, in particular:

1. We can no longer use @Setup in tests to open databases, because that function is non-suspending and doesn't run in the test's coroutine scope. Instead, I wrote a utility (the databaseTest function) that creates an ActiveDatabaseTest instance encapsulating all that logic. This ensures that the full lifecycle (initializing databases, running tests, closing databases) happens within the test's coroutine scope.
2. The runBlocking initializer in PowerSyncDatabaseImpl is incompatible with the new tests. I think this is because the connection pool also uses the coroutine scope from tests now (which is no longer a GlobalScope). And the runBlocking then prevents that scope from progressing? I'm not 100% sure about this, but there was some deadlock with runBlocking when opening the database.
   A workaround that I think is also beneficial for apps is to move the initialization into a Job that is then awaited before each other method. This is the same pattern we use for Dart and JavaScript as well, and ensures we're not accidentally blocking any UI thread that might be opening the PowerSync database.

[stevensJourney]

Excellent work!