Как получить указатель функции на общую лямбду?

Шаблон переменных — это прекрасно.
Даже способ их инициализации хорош.

Просто имейте в виду, что это шаблон для переменных, а не переменная, хранящая шаблон (который не может существовать).

Таким образом, при его окончательном использовании все разваливается:

Как компилятору узнать, какой из бесчисленного множества потенциальных экземпляров вы имеете в виду?
Все просто: вам нужно фактически рассказать:

int main(){
    fp<int, int>(1, 2);
    fp<char, char>('a', 'b');
}

Конечно, ручное удаление сахара из лямбды и получение ее экземпляра было бы более практичным:

struct {
    template <class T1, class T2>
    void operator()(T1 a, T2 b) const {
        std::cout << a << "--" << b << std::endl;
    };
} fp;

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

struct A = []...;
struct B : []... {
};
using C = []...;

У вас не может быть такого указателя шаблонной функции, но помните, что лямбда — это просто синтаксический сахар, вы можете просто написать класс самостоятельно.

class fp {
    template<class AT, class BT>
    void operator()(AT&& a, BT&& b) {
        std::cout << a << "--" << b << std::endl; 
    };
};
class class_with_functionoid_member {
    fp fn_;
};

И более общая версия будет заключаться в том, что вы можете иметь лямбду в качестве члена. Вы должны взять тип лямбда в качестве параметра класса.

template<class fnT> 
class class_with_lambda_member {
    fnT fn_;
public:
    class_with_lambda_member(fnT fn) : fn_(std::move(fn)) {}
};

Суть в том, что указатель на функцию — это тип стирания типа во время выполнения, а функции-члены шаблона требуют отложенного создания экземпляров во время компиляции, а C++ не может смешивать эти две концепции. Все обходные пути, которые приходят на ум, вращаются вокруг явного перечисления всех возможных комбинаций T1 и T2` в интерфейсе, который не смешивается с указателем на функцию, но может работать с объектом, выглядящим как указатель на функцию.

struct erasable_functions {
    virtual ~erasable_functions(){}
    virtual void operator()(int, int)=0;
    virtual void operator()(int, char)=0;
    virtual void operator()(char, int)=0;
    virtual void operator()(char, char)=0;
};

template<class lambdaT>
struct erased_functions : erasable_functions {
    lambdaT lambda_;
    erased_functions(lambdaT lambda) : lambda_(std::move(lambda)){}
    virtual void operator()(int a, int b) {lambda_(a, b);
    virtual void operator()(int a, char b) {lambda_(a, b);
    virtual void operator()(char a, int b) {lambda_(a, b);
    virtual void operator()(char a, char b) {lambda_(a, b);
};
template<class lambdaT>
erased_functions<lambdaT> erase_functions(lambdaT lambda)
{return {std::move(lambda)};}

struct class_with_functionoid_member {
    erasable_functions* functions_;
    class_with_functionoid_member(erasable_functions* functions) : functions_(functions){}
    void operator()(int a, int b) {(*functions_)(a, b);
    void operator()(int a, char b) {(*functions_)(a, b);
    void operator()(char a, int b) {(*functions_)(a, b);
    void operator()(char a, char b) {(*functions_)(a, b);
};

int main() {
    auto lambda = erase_functions([](auto a, auto b) {
            std::cout << a << "--" << b << std::endl;
        };
    class_with_functionoid_member c(&lambda);
}