下面的代码（从更复杂的代码中得到的简化示例）无法用GCC11.3.0编译

#include <array>
#include <memory>
#include <tuple>

namespace tools {
  template <typename U, typename W, std::size_t N>
  void operator*=(std::array<U, N>& a, const W& b) {
    for (auto& x : a)
      x *= b;
  }
}

namespace nameA {
  template <typename Jclass>
  struct Abase {
    
    template <typename... U>
    void calc(const typename Jclass::Utype& v, typename Jclass::Wtype& out, std::tuple<U...> par) const;
  };

  template <typename Jclass>
  template <typename... U>
  void Abase<Jclass>::calc(const typename Jclass::Utype& v, typename Jclass::Wtype& out, std::tuple<U...> par) const
  {
    std::unique_ptr<Jclass> j{new Jclass};
    std::apply([&](auto&&...x) { return j->calc(v, out, x...); }, par);
  }
}

template <std::size_t N, std::size_t M>
struct outtype {
  std::array<int, N> a;
  std::array<int, M> b;

private:
  template <class F, class... ArgsType>
  void doall(F&& f, ArgsType... args) { f(a, std::forward<ArgsType>(args)...); f(b, std::forward<ArgsType>(args)...); }

public:
  void operator*=(int rhs) { doall([&](auto& el) { using tools::operator*=; el *= rhs; }); }
};

namespace nameA {
  template <typename U, typename W>
  struct Jbase {
    using Utype = U;
    using Wtype = W;
    template <typename D>
    void calc(const U& in, W& out, const D& d) const
    {
      f(in, out);
      out *= d;
    }
    virtual void f(const U& in, W& out) const = 0;
  };
}

struct J : public nameA::Jbase<std::array<int, 3>, outtype<3, 3>> {
  virtual void f(const std::array<int, 3>& in, outtype<3, 3>& out) const { out.a = in; out.b = in; }
};

int main()
{
  nameA::Abase<J> a;
  std::array<int, 3> in = { 1, 2, 3 };
  outtype<3, 3> out;
  a.calc(in, out, std::make_tuple(4));
}

字符串
我编译的代码

g++ -Wall -pedantic -std=c++17 -o test test.cpp

型
我得到的错误是

test.cpp:40:80: error: no match for ‘operator*=’ (operand types are ‘std::array<int, 3>’ and ‘int’)
   40 |   void operator*=(int rhs) { doall([&](auto& el) { using tools::operator*=; el *= rhs; }); }

型
g++的版本是11.3.0。
这看起来很奇怪，因为我在传递给doall的lambda函数中显式地有using tools::operator*=。编译器也没有给予operator*=的候选列表。
链接到godbolt，在那里可以测试代码。
如果我换掉

void operator*=(int rhs) { doall([&](auto& el) { using tools::operator*=; el *= rhs; }); }

型
与

void operator*=(int rhs) { doall([&](auto& el) { tools::operator*=(el, rhs); }); }

型
则代码编译时没有警告。我看不出这两种选择有什么不同。
此外，使用较新的gcc 13.1.1，代码可以编译。
这是gcc 11.3.0的bug吗？