Add Handle::into_inner method

[MichaReiser]

This PR adds a into_inner function to Handle.

Being able to go back to the database can be useful for methods that take a Database as argument but have to create a Handle because they run concurrent code.
It is then desired that the method can return a Database to avoid that the entire code base has to use a Handle<Db>.

Example:

    #[allow(clippy::print_stderr)]
    fn run(mut self, db: RootDatabase) -> RootDatabase {
        // Schedule the first check.
        let mut db = salsa::Handle::new(db);
        self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
        let mut revision = 0usize;

        while let Ok(message) = self.receiver.recv() {
            tracing::trace!("Main Loop: Tick");

            match message {
                MainLoopMessage::CheckWorkspace => {
                    let db = db.clone();
                    let sender = self.sender.clone();

                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
                    // to prevent blocking the main loop here.
                    rayon::spawn(move || {
                        if let Ok(result) = db.check() {
                            // Send the result back to the main loop for printing.
                            sender
                                .send(MainLoopMessage::CheckCompleted { result, revision })
                                .ok();
                        }
                    });
                }

                MainLoopMessage::CheckCompleted {
                    result,
                    revision: check_revision,
                } => {
                    if check_revision == revision {
                        eprintln!("{}", result.join("\n"));

                        if self.verbosity == Some(VerbosityLevel::Trace) {
                            eprintln!("{}", countme::get_all());
                        }
                    }

                    if self.watcher.is_none() {
                        return db.into_inner();
                    }
                }

                MainLoopMessage::ApplyChanges(changes) => {
                    revision += 1;
                    // Automatically cancels any pending queries and waits for them to complete.
                    db.get_mut().apply_changes(changes);
                    if let Some(watcher) = self.watcher.as_mut() {
                        watcher.update(&db);
                    }

                    self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
                }
                MainLoopMessage::Exit => {
                    return db.into_inner();
                }
            }
        }

        db.into_inner()
    }

Why not just pass in a Handle

This is a possibility but it leaks that the function uses concurrency internally and one also has to be careful to pass in a &mut Handle<T> and to not clone it on the call-site (which I did) because it then results in a dead lock when calling get_mut.

[netlify]

✅ Deploy Preview for salsa-rs canceled.

Name	Link
🔨 Latest commit	c66f600
🔍 Latest deploy log	https://app.netlify.com/sites/salsa-rs/deploys/66a35e0b2243090008d45525