remove the DB parameter

This had two unexpected consequences, one unfortunate, one "medium":

* All `salsa::Database` must be `'static`. This falls out from
`Q::DynDb` not having access to any lifetimes, but also the defaulting
rules for `dyn QueryGroup` that make it `dyn QueryGroup + 'static`. We
don't really support generic databases anyway yet so this isn't a big
deal, and we can add workarounds later (ideally via GATs).

* It is now statically impossible to invoke `snapshot` from a query,
and so we don't need to test that it panics. This is because the
signature of `snapshot` returns a `Snapshot<Self>` and that is not
accessible to a `dyn QueryGroup` type. Similarly, invoking
`Runtime::snapshot` directly is not possible becaues it is
crate-private. So I removed the test. This seems ok, but eventually I
would like to expose ways for queries to do parallel
execution (matklad and I had talked about a "speculation" primitive
for enabling that).

* This commit is 99% boilerplate I did with search-and-replace. I also
rolled in a few other changes I might have preferred to factor out,
most notably removing the `GetQueryTable` plumbing trait in favor of
free-methods, but it was awkward to factor them out and get all the
generics right (so much simpler in this version).

tests/cycles.rs

@@ -39,50 +39,50 @@ trait Database: salsa::Database {
     fn cycle_c(&self) -> Result<(), Error>;
 }
 
-fn recover_a(_db: &impl Database, cycle: &[String]) -> Result<(), Error> {
+fn recover_a(_db: &dyn Database, cycle: &[String]) -> Result<(), Error> {
     Err(Error {
         cycle: cycle.to_owned(),
     })
 }
 
-fn recover_b(_db: &impl Database, cycle: &[String]) -> Result<(), Error> {
+fn recover_b(_db: &dyn Database, cycle: &[String]) -> Result<(), Error> {
     Err(Error {
         cycle: cycle.to_owned(),
     })
 }
 
-fn memoized_a(db: &impl Database) -> () {
+fn memoized_a(db: &dyn Database) -> () {
     db.memoized_b()
 }
 
-fn memoized_b(db: &impl Database) -> () {
+fn memoized_b(db: &dyn Database) -> () {
     db.memoized_a()
 }
 
-fn volatile_a(db: &impl Database) -> () {
+fn volatile_a(db: &dyn Database) -> () {
     db.salsa_runtime().report_untracked_read();
     db.volatile_b()
 }
 
-fn volatile_b(db: &impl Database) -> () {
+fn volatile_b(db: &dyn Database) -> () {
     db.salsa_runtime().report_untracked_read();
     db.volatile_a()
 }
 
-fn cycle_leaf(_db: &impl Database) -> () {}
+fn cycle_leaf(_db: &dyn Database) -> () {}
 
-fn cycle_a(db: &impl Database) -> Result<(), Error> {
+fn cycle_a(db: &dyn Database) -> Result<(), Error> {
     let _ = db.cycle_b();
     Ok(())
 }
 
-fn cycle_b(db: &impl Database) -> Result<(), Error> {
+fn cycle_b(db: &dyn Database) -> Result<(), Error> {
     db.cycle_leaf();
     let _ = db.cycle_a();
     Ok(())
 }
 
-fn cycle_c(db: &impl Database) -> Result<(), Error> {
+fn cycle_c(db: &dyn Database) -> Result<(), Error> {
     db.cycle_b()
 }