Is it possible to call clone on a struct that contains a FnMut closure trait object?

Question

I have a loop that pops items off a queue, invokes the callback with the item and then needs to add the item back on to the queue. The reason for this is that the items are really repeating timers, however I have removed any timer code in this simple example for brevity. Is it possible to clone the Item after it has been moved or is there a better way to handle this?

pub trait ItemCb: Send {
    fn call(&mut self, item: Item);
}

impl<F: Send> ItemCb for F
where
    F: FnMut(Item),
{
    fn call(&mut self, item: Item) {
        self(item)
    }
}

pub struct Item<'a> {
    cb: Option<Box<dyn ItemCb + 'a>>,
    data: i32,
}

impl<'a> Item<'a> {
    pub fn new(cb: impl ItemCb + 'a, data: i32) -> Self {
        Self {
            cb: Some(Box::new(cb)),
            data,
        }
    }
}

fn main() {
    let mut items = vec![Item::new(|_i: Item| println!("hello world!"), 1)];
    loop {
        if let Some(mut item) = items.pop() {
            // TODO cannot clone item
            let cloned_item = item.clone();

            let mut cb = item.cb.take().unwrap();
            cb.call(item);

            // Add the item back to the queue to be processed again
            items.push(cloned_item);
        }
    }
}

error[E0599]: no method named `clone` found for struct `Item<'_>` in the current scope
   --> src/main.rs:33:36
    |
14  | pub struct Item<'a> {
    | ------------------- method `clone` not found for this
...
33  |             let cloned_item = item.clone();
    |                                    ^^^^^ method not found in `Item<'_>`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following trait defines an item `clone`, perhaps you need to implement it:
            candidate #1: `Clone`