[core] Inline Mutex/LockGuard on single-threaded platforms

When USE_ESP8266 or USE_RP2040 is defined, provide a fully inline
no-op Mutex class in the header. This allows the compiler to
eliminate all lock/unlock call overhead instead of generating
calls to empty function stubs.

esphome/components/esp8266/helpers.cpp

@@ -12,12 +12,7 @@ namespace esphome {
 uint32_t random_uint32() { return os_random(); }
 bool random_bytes(uint8_t *data, size_t len) { return os_get_random(data, len) == 0; }
 
-// ESP8266 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
-Mutex::Mutex() {}
-Mutex::~Mutex() {}
-void Mutex::lock() {}
-bool Mutex::try_lock() { return true; }
-void Mutex::unlock() {}
+// ESP8266 Mutex is defined inline in helpers.h when ESPHOME_THREAD_SINGLE is set.
 
 IRAM_ATTR InterruptLock::InterruptLock() { state_ = xt_rsil(15); }
 IRAM_ATTR InterruptLock::~InterruptLock() { xt_wsr_ps(state_); }

esphome/components/rp2040/helpers.cpp

@@ -35,12 +35,7 @@ bool random_bytes(uint8_t *data, size_t len) {
   return true;
 }
 
-// RP2040 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
-Mutex::Mutex() {}
-Mutex::~Mutex() {}
-void Mutex::lock() {}
-bool Mutex::try_lock() { return true; }
-void Mutex::unlock() {}
+// RP2040 Mutex is defined inline in helpers.h when ESPHOME_THREAD_SINGLE is set.
 
 IRAM_ATTR InterruptLock::InterruptLock() { state_ = save_and_disable_interrupts(); }
 IRAM_ATTR InterruptLock::~InterruptLock() { restore_interrupts(state_); }

esphome/core/helpers.h

@@ -1737,15 +1737,23 @@ template<typename T> class Parented {
  */
 class Mutex {
  public:
-  Mutex();
   Mutex(const Mutex &) = delete;
+  Mutex &operator=(const Mutex &) = delete;
+
+#if defined(USE_ESP8266) || defined(USE_RP2040)
+  // Single-threaded platforms: inline no-ops so the compiler eliminates all call overhead.
+  Mutex() = default;
+  ~Mutex() = default;
+  void lock() {}
+  bool try_lock() { return true; }
+  void unlock() {}
+#else
+  Mutex();
   ~Mutex();
   void lock();
   bool try_lock();
   void unlock();
 
-  Mutex &operator=(const Mutex &) = delete;
-
  private:
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   SemaphoreHandle_t handle_;
@@ -1753,6 +1761,7 @@ class Mutex {
   // d-pointer to store private data on new platforms
   void *handle_;  // NOLINT(clang-diagnostic-unused-private-field)
 #endif
+#endif  // single-threaded check
 };
 
 /** Helper class that wraps a mutex with a RAII-style API.