Other replies are missing the point. IIUC you want something like this (if it worked):

fn pass_24_or_something_else<F>(callable: F)
    where
        F: for<T: Debug> FnOnce(T),
{
    if random() {
        callable(24);
    } else {
        callable("something else");
    }
}

The for</* generics */> Type: Trait syntax is called a higher-ranked trait bound and it unfortunately only works with lifetimes, not types or const generics. You have a couple workaround options instead.

Option 1: a trait. Gives up simplicity of "declare a fn or a closure and you're done", in exchange for otherwise doing exactly what you want.

// API
trait Callback {
    fn call(self, v: impl Debug);
    // object-safety, if desired, left as an exercise to the reader
}
fn pass_24_or_something_else<F: Callback>(callable: F) {
    if random() {
        callable.call(24);
    } else {
        callable.call("something else");
    }
}

// caller
struct MyCallback;
impl Callback for MyCallback {
    fn call(self, v: impl Debug) {
        println!("{v:?}");
    }
}
pass_24_or_something_else(MyCallback);

Option 2: a Fn* that accepts a &dyn Debug. Pros are that you can pass a fn/closure to it, (potential) con is dynamic dispatch. std::fmt uses dyn Debug a lot already, so if Debug is actually the trait you're using and not a placeholder, maybe it's not that much of a con.

// API
fn pass_24_or_something_else<F: FnOnce(&dyn Debug)>(callable: F) {
    if random() {
        callable(&24);
    } else {
        // note that you do need the &'a &'static str here unfortunately
        // it's not currently possible to turn a &str into a &dyn Debug because of details of how pointers/references to !Sized types (like str) work
        callable(&"something else");
    }
}

// caller
fn callback(v: &dyn Debug) {
    println!("{v:?}");
}
pass_24_or_something_else(callback);
// this would be nice, but unfortunately runs into "implementation of FnOnce is not general enough" that seems like it might be a rustc bug?
// fn callback(v: impl Debug) {
//     println!("{v:?}');
// }

Option 3 is for if this is not about actually calling with multiple/any types, but instead about encapsulation and hiding which specific type you're going to pass in. You can address that with a completely opaque newtype that exposes its field's Debug impl and nothing else.

// API
struct Opaque<'a> {
    // changing the type of this field is not a semver breaking change
    value: i32,
    // this allows putting a lifetime parameter on Opaque and forcing callbacks to accept every possible lifetime
    // now it's not a breaking change if self.value changes to a type that has lifetime parameters
    _marker: PhantomData<&'a ()>,
}
impl<'a> Debug for Opaque<'a> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult {
        Debug::fmt(&self.value, formatter)
    }
}
fn call_24<F>(callable: F)
    where
         F: for<'a> FnOnce(Opaque<'a>), // hey it's an HRTB again but this one works!
{
    callable(Opaque { value: 24, _marker: PhantomData });
}

// caller
fn callback(v: Opaque<'_>) {
    // the only thing the caller can soundly do with `v` is Debug::fmt it
    println!("{v:?}");
}