Коммутативный оператор перегрузки + 2 разных объектов

Да, вам нужны обе версии. Но вы можете перенаправить одно на другое, если операция действительно коммутативна.

RegularMatrix operator+(const SparseMatrix &a, const RegualarMatrix &b) {
    return b + a;
}

Требуются обе версии, просто напишите после первой перегрузки:

RegularMatrix operator+(const SparseMatrix &a, const RegualarMatrix &b)
{
    return operator+(b,a);
}

или более простая версия:

RegularMatrix operator+(const SparseMatrix &a, const RegualarMatrix &b)
{
    return b + a;
}

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

#include <iostream>    // std::cout
#include <utility>     // std::pair
#include <type_traits> // std::remove_cvref_t
#include <concepts>    // std::same_as

// These two utilities will be used for all commutative functions:

template <typename T, typename U, typename V, typename W>
concept commutative =
    (std::same_as<std::remove_cvref_t<T>, V> && std::same_as<std::remove_cvref_t<U>, W>) ||
    (std::same_as<std::remove_cvref_t<U>, V> && std::same_as<std::remove_cvref_t<T>, W>);

template <typename V, typename W, typename T, typename U>
requires commutative<T, U, V, W>
constexpr decltype(auto) order (T && a, U && b) {
    if constexpr (std::same_as<std::remove_cvref_t<T>, V>)
        return std::pair{std::forward<T>(a), std::forward<U>(b)};
    else
        return std::pair{std::forward<U>(b), std::forward<T>(a)};
}

// Here goes the use-case:

struct A {
    int aval;
};

struct B {
    int bval;
};

// This template declaration allows two instantiations:
// (A const &, B const &) and (B const &, A const &)
template <typename T, commutative<T, A, B> U>
A operator + (T const & first, U const & second) {
    // But now we need to find out which is which:
    auto const & [a, b] = order<A, B>(first, second);
    return {.aval = a.aval + b.bval};
}

// Just to test it:
int main () {
    A a = {.aval = 1};
    B b = {.bval = 2};

    A c = a + b;
    A d = b + a;

    std::cout << c.aval << '\n';
    std::cout << d.aval << '\n';
}

Если template <typename T, commutative<T, A, B> U> и auto const & [a, b] = order<A, B>(first, second); меньше стандартного кода, чем повторение всего определения с return b + a; для вашего сценария, то я думаю, это может быть полезно.