The best way to implement cloneable c++ classes?

You could use the Curious Recurring Template Pattern where a derived class actually derives from an instanciation of it base class depending on itself. Demo:

#include <iostream>

template<typename T>
class Clonable {
public:
    T* clone() {
        return new T { * static_cast<T *>(this)};
    }
};

template<class T>
class Base : public Clonable<T> {
public:
    int x = 2;

    virtual ~Base() {}
};

class Derived : public Base<Derived> {
public:
    int y = 3;
};

int main() {
    Base<Derived> *d = new Derived;

    static_cast<Derived *>(d)->y = 6;

    Derived *c = d.clone();  // we are even cloning from a Base *!
    std::cout << c->x << ' ' << c->y << '\n';
    delete c;
    delete d;
}

It compiles with no warning and correctly outputs 2 6, proving that no slicing occurred.

Your Cloneable is missing a cast. this is a Cloneable *, it needs to be cast to T * to be passed to the copy constructor.

template<typename T, typename B> class Cloneable : public B
{
public:
    B* clone() override { return new T(*static_cast<T*>(this)); }
};

class Base
{
public:
    virtual Base* clone() = 0;
};

class Derived : public Cloneable<Derived, Base>
{
};

See it live

This doesn't stop someone from further subclassing Derived, and forgetting to reimplement clone for that grandchild class.

class Oops : public Derived {};

int main() {
    Oops o;
    Base * pb = o.clone();
    assert(typeid(*pb) != typeid(o));
}