Посмотрите, вот при таком подходе есть ли подводные камни?

#include <any>
#include <functional>
#include <iostream>

struct ICar
{

virtual std::string alarm() const = 0;

virtual ~ICar() = default;
};

struct Ferrari : ICar
{

std::string alarm() const override
{
return std::string{"Ferrari"};
}
};

struct Lada : ICar
{

std::string alarm() const override
{
return std::string{"Lada"};
}
};

struct Nocar : ICar
{

std::string alarm() const override
{
return std::string{"NO CAR"};
}
};

// кладет в себя производный тип как есть, но при этом еще и сразу кладет
// в указатель на функцию как скастовать его обратно в нужный тип
// когда надо обратно он прогоняет сквозь функцию кастования и получает изначальный тип
// но возвращаем в указатель на базовый наружу.
// этот подход убирает телодвижения с виртуальными clone() если б мы просто хранили указатель на базовый
class Carpoly
{
public:
template <typename ConcreteCar>
Carpoly(ConcreteCar &&concrete_type)
: storage{std::forward<ConcreteCar>(concrete_type)},
getter{[](std::any &storage) -> ICar & { return std::any_cast<ConcreteCar &>(storage); }}
{
}

ICar *operator->()
{
return &getter(storage);
}

private:
std::any storage;
ICar &(*getter)(std::any &);
};

struct Garage
{

template <class T> auto make_car()
{
return Carpoly{T{}};
}

void set_lada()
{
mycar_ = make_car<Lada>();
}

void set_ferrari()
{
mycar_ = make_car<Ferrari>();
}

std::string beep()
{
return mycar_->alarm();
}

Carpoly mycar_{Nocar{}};
};

int main()
{
Garage mygarage;
mygarage.set_lada();
std::cout << mygarage.beep() << std::endl;
mygarage.set_ferrari();
std::cout << mygarage.beep() << std::endl;

return 0;
}

А чем не устроил вариант сразу же с хранением указателя на ICar?

А зачем тут виртуальный clone? Нам же просто надо вызвать метод alarm у машины. Это же обычный виртуальный вызов. Зачем городить городушки в виде Carpoly, если там в итоге все равно вернется указатель на ICar? void beep(ICar & car) { car.alarm(); } Lada lada; beep(lada); Ferrari ferrari; beep(ferrari);