C++ template dispatching not calling the correct function

Remark: the following doesn't answer your specific point (see the accepted answer for that)

Note however that instead of having some kind of runtime error (i.e. with a call to the "unsupported types" version), you could make sure at compile time that process_data can't be used with wrong arguments, and it is always better to detect errors at compile time rather than at runtime when possible.

You can do that with static_assert, e.g.

template <typename A, typename B>
void process_data(int_tag, const A& a, const B& b) {
    static_assert (std::is_integral_v<A> && std::is_integral_v<B>);
    std::cout << "Result: " << (a + b) << "\n";
}
template <typename A, typename B>
void process_data(float_tag, const A& a, const B& b) {
    static_assert (std::is_floating_point_v<A> && std::is_floating_point_v<B>);
    std::cout << "Result: " << (a * b) << "\n";
}

You don't need anymore to define a default process_data with a default "unsupported types" implementation

You can use it as follows:

int main() {
    std::cout << "int   : ";  process_data(int_tag{}, 10, 20);  // Should print: Result: 30
    std::cout << "float : ";  process_data(float_tag{}, 3.14f, 2.0f);  // Should print: Result: 6.28
    // would not compile:    std::cout << "string: ";  process_data(int_tag{}, "Hello", "World");  // Should print: <unsupported type>
    return 0;
}

Demo

Not a direct answer, but might be useful:

Since you mentioned you use C++20 (-std=c++20), you could use Constraints and concepts to make the code more readable.

Below is an example using requires clauses:

#include <iostream>
#include <type_traits>

struct int_tag {};
struct float_tag {};

template <typename Tag, typename A, typename B>
void process_data(Tag, const A&, const B&) {
    std::cout << "<unsupported type>" << "\n";
}

template <typename A, typename B>
    requires std::integral<A> && std::integral<B>
void process_data(int_tag, const A& a, const B& b) {
    std::cout << "Result: " << (a + b) << "\n";
}

template <typename A, typename B>
    requires std::floating_point<A> && std::floating_point<B>
void process_data(float_tag, const A& a, const B& b) {
    std::cout << "Result: " << (a * b) << "\n";
}

int main() {
    std::cout << "[process_data for int_tag]\n";
    std::cout << "int: ";
    process_data(int_tag{}, 10, 20);  // Should print: Result: 30
    std::cout << "float: ";
    process_data(float_tag{}, 3.14f, 2.0f);  // Should print: Result: 6.28
    std::cout << "string: ";
    process_data(int_tag{}, "Hello", "World");  // Should print: <unsupported type>
}

Output:

[process_data for int_tag]
int: Result: 30
float: Result: 6.28
string: <unsupported type>

Live demo

Your current version is failing to work because your enable_if_t clauses are written wrong. It is wrong because you should stop using enable_if_t clauses in C++20 code.

A basic tag dispatching solution should look like this:

namespace processing { // always in a namespace
  // default implementation: (I usually =delete this)
  template <class Tag, class A, class B>
  void process_data(Tag, A const&, B const&) {
    std::cout << "<unsupported type>" << "\n";
  }

  // create both type and value tags:
  struct int_tag_t {};
  constexpr int_tag_t int_tag = {};
  struct float_tag_t {};
  constexpr float_tag_t float_tag = {};

  // tag overloads using concepts:
  void process_data(int_tag_t, std::integral auto const& a, std::integral auto const& b) {
    std::cout << "Result: " << (a + b) << "\n";
  }
  void process_data(float_tag_t, std::floating_point auto const& a, std::floating_point auto const& b) {
    std::cout << "Result: " << (a * b) << "\n";
  }
}
using processing::process_data; // if needed

remember, you can't partially specialize template functions; only overload them.

This has the problem that it effectively reserves process_data name in every namespace. To get around this, we can use a fancier customization point system using tag_invoke:

 namespace processing {
   struct process_data_cpo;
   template<class Tag>
   void tag_invoke( std::tag_t<process_data_cpo>, Tag, auto const&... );

   struct process_data_cpo {
     template<class Tag, class A, class B>
     constexpr void operator()(Tag tag, A const& a, B const& b)const{
       return tag_invoke( std::tag_t<process_data_cpo>{}, tag, a, b );
     }
   };
   constexpr process_data_cpo process_data;

   template<class Tag>
   void tag_invoke( process_data_cpo, Tag, auto&&... ) {
     std::cout << "<unsupported type>" << "\n";
   }
   
  // create both type and value tags:
  struct int_tag_t {};
  constexpr int_tag_t int_tag = {};
  struct float_tag_t {};
  constexpr float_tag_t float_tag = {};

  // tag overloads using concepts:
  void tag_invoke(std::tag_t<process_data_cpo>, int_tag_t, std::integral auto const& a, std::integral auto const& b) {
    std::cout << "Result: " << (a + b) << "\n";
  }
  void tag_invoke(std::tag_t<process_data_cpo>, float_tag_t, std::floating_point auto const& a, std::floating_point auto const& b) {
    std::cout << "Result: " << (a * b) << "\n";
  }
 }

now we use tag_invoke for the ADL portion, and we no longer have to reserve process_data in every namespace to avoid ADL quirks. To add customizations, you just override tag_invoke( std::tag_t<data_processing::process_data_cpo>, ... ) in either a namespace of your tag, a namespace of your types, or in data_processing namespace, and data_processing::process_data( tag, a, b ) will find it.