Fix a concurrent issue in MariaModule in sql/threadpool_generic.cc and sql/threadpool_generic.h.

Background:
The MariaModule is registered as a module of brpc. The groups_ vector in MariaModule stores pointers to thread_group_t. These pointers are accessed by external worker threads in Process() and HasTask(), and by SQL threads in ExtThdStart() and ExtThdEnd().
Concurrently, the groups_ vector is modified in ResizeGroups() and SetGroup() when the thread pool size changes (e.g., via TP_pool_generic::set_pool_size).

Issue:
There is no synchronization between threads reading from groups_ and threads writing to it.
Specifically:

1. ResizeGroups() calls groups_.resize(size, nullptr), which fills new slots with nullptr and may reallocate the vector's internal storage, causing data races with concurrent readers.
2. Process(), HasTask(), ExtThdStart(), and ExtThdEnd() do not check if the retrieved thread_group_t* is nullptr before dereferencing it (e.g., group->shutdown.load() or group->ext_worker_active_.store()).
3. GDB reports that group can be 0x0 even if groups_[thd_id] appears non-zero later, indicating a memory visibility/concurrency issue.

Requested Fix:

1. In sql/threadpool_generic.h, add a mutable std::mutex groups_mutex_; to the MariaModule class.
2. In sql/threadpool_generic.h, ensure #include <mutex> is available for the MariaModule class (move it out of #ifdef COROUTINE_ENABLED if necessary or add it to the ELOQ_MODULE_ENABLED block).
3. In sql/threadpool_generic.cc, update ExtThdStart, ExtThdEnd, Process, and HasTask to:
   • Use std::lock_guard<std::mutex> with groups_mutex_ when accessing the groups_ vector to get the thread_group_t*.
   • Add a check to return immediately if the retrieved group pointer is nullptr.
4. Update ResizeGroups and SetGroup (either in .h or .cc) to use groups_mutex_ to protect the vector modification.

Example of desired pattern in Process:

void MariaModule::Process(int thd_id)
{
 thread_group_t *group = nullptr;
 {
 std::lock_guard<std::mutex> lk(groups_mutex_);
 if (thd_id >= 0 && (size_t)thd_id < groups_.size()) {
 group = groups_[thd_id];
 }
 }
 if (group == nullptr || group->shutdown.load(std::memory_order_relaxed))
 {
 return;
 }
 // ... rest of the function
}

Apply similar patterns to ExtThdStart, ExtThdEnd, and HasTask. Note that HasTask is const, so the mutex must be mutable.