Неявное преобразование класса шаблона Variadic

Все сложно...

Прежде всего: у вас есть рекурсивный класс-шаблон BasicValidationPolicy, в котором вы определяете два метода и хотите, чтобы все методы для всех шагов рекурсии класса были доступны.

К сожалению, определение методов в производных классах скрывает методы в базовых классах.

Чтобы скрыть унаследованные методы, вы должны явно добавить пару using

using BasicValidationPolicy<Rest...>::Set;
using BasicValidationPolicy<Rest...>::RegisterSetHandler;

На данный момент код не компилируется, потому что вам нужны Set() и RegisterSetHandler() в классе основного случая. Вас объявили пустышкой RegisterSetHandler(), но не пустышкой Set(). Вы должны добавить один, чтобы основной случай стал

template <>
class BasicValidationPolicy<>
{
public:
    void RegisterSetHandler();
    void Set();
};

Теперь ваш объект MyClass<Policy> предоставляет два метода RegisterSetHandler() (до одного): один получает std::function<void(int, std::int64_t)>, другой (до того, как скрытый) получает std::function<void(int, double)>.

Но когда вы передаете лямбду, возникает проблема курицы и яйца: лямбда может быть преобразована в std::function, но не является std::function. Поэтому его нельзя использовать для вывода параметров шаблона std::function, потому что типы должны быть известны до их вывода.

Возможное решение - наложить преобразование лямбда/std::function в вызов

// ..........................VVVVVVVVVVVVVV
m.Policy::RegisterSetHandler(std::function{[](int i, double value) {
                             // by this point value is an int64_t
                             std::cout << "Got double " << i << ", " << value << "\n";
                             }});
// ...........................^

используя также руководства по дедукции шаблонов, представленные в C++17.

Таким образом, ваш код становится

#include <iostream>
#include <functional>

template <typename... T>
class BasicValidationPolicy { };

template <>
class BasicValidationPolicy<>
{
public:
    void RegisterSetHandler();
    void Set();
};

template <typename T, typename... Rest>
class BasicValidationPolicy<T, Rest...> : public BasicValidationPolicy<Rest...>
{
public:
    using SetHandler = std::function<void(int, T)>;

    using BasicValidationPolicy<Rest...>::Set;
    using BasicValidationPolicy<Rest...>::RegisterSetHandler;
    
    void RegisterSetHandler(const SetHandler& handler)
    {
        m_setHandler = handler;
    }
    
    void Set(int n, const T& val) {
        if (m_setHandler) {
            m_setHandler(n, val);
        }
    }
    
private:
    SetHandler m_setHandler{nullptr};
};

template <typename ValidatorPolicy>
class MyClass : public ValidatorPolicy  {
public:

    void OnSetInt(int n, int64_t v)
    {
        ValidatorPolicy::Set(n, v);
    }
    
    void OnSetDouble(int n, double d)
    {
        ValidatorPolicy::Set(n, d);
    }
};


int main ()
 {
   using Policy = BasicValidationPolicy<int64_t, double>; // doesn't work
   MyClass<Policy> m;
    
   m.Policy::RegisterSetHandler(std::function{[](int i, double value) {
                                std::cout << "Got double " << i << ", " << value << "\n";
                                }});
   
    double d{35.2135}; 
    m.OnSetDouble(1, d);
}

Есть небольшая альтернатива рекурсивному определению, с которой может быть проще работать...

template<typename T>
class ValidationPolicy {
  // Set/Register/etc
};

template <typename... Ts>
class BasicValidationPolicy : public ValidationPolicy<Ts>... {
 public:
  using ValidationPolicy<Ts>::Set...;
  using ValidationPolicy<Ts>::RegisterSetHandler...;
};

Это может иметь некоторое влияние на время компиляции и другие аспекты разработки, хотя, скорее всего, относительно незначительное. Например, если у вас есть десятки классов, используемых в сотнях различных комбинаций политик в вашем приложении, рекурсивное определение приведет к тому, что для его поддержки будет гораздо больше различных типов и более крупных двоичных файлов. Например, в рекурсивном определении BasicValidationPolicy<T1, T2, T3> и BasicValidationPolicy<T3, T2, T1> использование будет генерировать 7 различных типов в иерархии (пустой используется в обоих расширениях). То же самое в более плоской иерархии будет 5 различных типов — по одному для каждого из T1, T2, T3 и по одному для каждой комбинации. Добавление BasicValidationPolicy<T2, T3, T1> рекурсивно добавит еще 3 типа, но еще 1 тип в плоской форме.

Ответ от @ max66 не является неправильным, просто есть над чем подумать.