Make Value an associated type of Queryable

[groue]

This PR makes it possible to derive sub-protocols of Queryable.

---

For example, given an app that has a PlayerStore object with the following api:

import GRDB

struct PlayerStore {
    var reader: GRDB.DatabaseReader { get }
}

The app can define convenience protocols as below:

/// A `Queryable` type that performs a single fetch. It is suitable for
/// views that must not change once they have appeared on screen.
protocol FetchQueryable: Queryable
where DatabaseContext == PlayerStore,
      ValuePublisher == AnyPublisher<Value, any Error>
{
    /// Returns the fetched value.
    func fetch(_ db: Database) throws -> Value
}

extension FetchQueryable {
    func publisher(in store: PlayerStore) -> ValuePublisher {
        Deferred {
            Result {
                try store.reader.read(fetch)
            }
            .publisher
        }
        .eraseToAnyPublisher()
    }
}

/// A `Queryable` type that observes the database.
protocol ObservationQueryable: Queryable
where DatabaseContext == PlayerStore,
      ValuePublisher == AnyPublisher<Value, any Error>
{
    /// Returns the observed value.
    func fetch(_ db: Database) throws -> Value
}

extension ObservationQueryable {
    func publisher(in store: PlayerStore) -> ValuePublisher {
        ValueObservation
            .tracking(fetch)
            .publisher(in: store.reader, scheduling: .immediate)
            .eraseToAnyPublisher()
    }
}

This can dramatically simplify the definition of some Queryable types:

-struct PlayersRequest: Queryable {
+struct PlayersRequest: FetchQueryable {
     static var defaultValue: [Player] = []
     
-    func publisher(in store: PlayerStore) -> AnyPublisher<[Player], any Error> {
-        Deferred {
-            Result {
-                try store.reader.read { db in
-                    try Player.fetchAll(db)
-                }
-            }
-            .publisher
-        }
-        .eraseToAnyPublisher()
-    }
+    func fetch(_ db: Database) throws -> [Player] {
+        try Player.fetchAll(db)
+    }
 }

-struct TeamsRequest: Queryable {
+struct TeamsRequest: ObservationQueryable {
     static var defaultValue: [Team] = []
     
-    func publisher(in store: PlayerStore) -> AnyPublisher<[Team], any Error> {
-        ValueObservation
-            .tracking { db in
-                try Team.fetchAll(db)
-            }
-            .publisher(in: store.reader, scheduling: .immediate)
-            .eraseToAnyPublisher()
-    }
+    func fetch(_ db: Database) throws -> [Team] {
+        try Team.fetchAll(db)
+    }
 }