Odd-ball approach that comes to mind, if compile-time checking is
insisted on:

    class Clonable {
    protected:
        template<class T>
        Clonable( T const* t )
        {
            // ensure that T implements covariant clone
            if ( false )
                t = t->clone();
        }

        // OK to remove this
        virtual Clonable* clone() const = 0;
    };

    class Base : protected virtual Clonable {
    public:
        Base() : Clonable( this ) { }
        Base* clone() const { return new Base( *this ); }
    };

    class Derived : public Base {
    public:
        Derived() : Clonable( this ) { }
        Derived* clone() const { return new Derived( *this ); }
    };

    class Error : public Derived {
    public:
        // error, Clonable doesn't have default ctor
        Error() /* : Clonable() */ { }
    };

    class Error2 : public Derived {
    public:
        // error, clone() doesn't return Error2*
        Error2() : Clonable( this ) { }
    };