What I had in mind is something like this:

#[macro_use]
extern crate rocket;

use rocket::request::{self, Request};

trait MyService<'r> {
    fn perform(&self) -> String;
}

struct MyServiceFactory {}

impl<'r> MyServiceFactory {
    async fn from_request(
        request: &'r Request<'_>,
    ) -> request::Outcome<Box<dyn MyService<'r>>, ()> {
        let db = request.guard::<Database>().await.succeeded()?;

        // Create a concreate `MyService` with a the DB
        // The service instance is then only valid for this request
    }
}

#[get("/hello/<name>/<age>")]
fn hello(name: &str, age: u8, service: Box<dyn MyService>) -> String {
    let result = service.perform();
    format!("Hello, {} year old named {}!", age, result)
}

#[launch]
fn rocket() -> _ {
    ...
    rocket::build()
        .attach(Database::init())
        .manage(MyServiceFactory {})
        .mount("/", routes![hello])
}

The MyServiceFactory is here to construct MyService (which itself is a trait).
In this mechanism, the actual State/Guard is not needed to be known at compile time but can be exchanged. E.g. for productoin I can have a different MyService implementation as for staging or testing.

In my concreate use case I need to have a different "Service" for testing and production. This would be a nice and elegant way to solve this.

In this mechanism, the actual State/Guard is not needed to be known at compile time

This isn't possible. The code generation emits code to construct the guard, using the guard type to identify which implementation to call. Rust, because it's a fully compiled language, doesn't support swapping out an implementation without recompiling.

From what it sounds like, you're looking to switch server you make requests against - why not just make it a configuration option, and extract it from the Rocket.toml?

This is possible. You just need to implement FromRequest for your Box<dyn Foo> type.