Talking about the errors / trait bounds / what is possible, and ignoring design considerations...
A lifetime parameter on a function means, "I can work with any lifetime that the caller chooses." All you know is that it lasts at least as long as your function body -- callers can't name any shorter lifetimes than that -- and any such lifetime is longer than you can borrow a local variable for.
For lifetimes shorter than the function body, you need higher-ranked trait bounds (HRTBs): for<'any> [bound...]. HTRBs mean something more like "the generic type that the caller supplies can work with any lifetime (that I, the function writer, choose)". Then you can work with lifetimes shorter than your function body (e.g. that borrow locals). As it so happens, you were already using one; these are all the same thing with varying amounts of syntactic sugar:
fn run<Callback>(mut callback: Callback) where Callback: FnMut(Info),
fn run<Callback>(mut callback: Callback) where Callback: FnMut(Info<'_>),
fn run<Callback>(mut callback: Callback)
where
Callback: for<'any> FnMut(Info<'any>),
And that's why your original compiled. (Incidentally, I recommend always writing Info<'_> instead of just Info, et cetera, to make implicit HRTB and implicit borrows more obvious in the code.)
After reading that, you might be tempted to try:
fn run<Res: for<'de> Deserialize<'de>, Callback>(mut callback: Callback)
where
Callback: FnMut(Res),
The method will compile with such a bound, but you won't be able to actually use it like you think. (Also in case you didn't know, DeserializedOwned is a convenient wrapper around that exact bound.)
There are two related problems, with the same root cause: Types that vary by lifetime are still distinct types. Info is not a type; it is a type constructor. What is a type is Info<'a> where 'a has taken on some specific, concrete lifetime. Another thing to understand is that generic type parameters must represent a single type, and not a type constructor like Info without a concrete lifetime.
The first problem is what the error message is about: There is no Info<'concrete> where Info<'concrete>: for<'any> Deserialize<'any>. Instead, Info<'concrete> implements Deserialize<'concrete>.
The second problem is that you need your closure to be generic over the input lifetime; you want a for<'any> FnMut(Info<'any>) like you had before. But you're trying to replace that with FnMut(Res) where Res is a type parameter. This won't work because, again, Res must represent a single type, not a type constructor.
Is there any way forward? Yes -- you can emulate generic type constructors by using a trait with a GAT, or with a GAT-emulating lifetime-taking trait.
However, the abstraction is somewhat complicated and it tends to completely wreck inference.
You can sometimes recover inference by replacing enough generic implementations with concrete ones. If you do so, the boilerplate grows enough you might want a macro you call on each type. (At this point there's an argument you're not gaining much with the generic framework over just macroing your original repetitive code.)