[api] Split ProtoVarInt::parse into 32-bit and 64-bit phases

On 32-bit platforms (ESP32 Xtensa), 64-bit shifts in varint parsing
compile to __ashldi3 library calls. Since the vast majority of protobuf
varint fields (message types, sizes, enum values, sensor readings) fit
in 4 bytes, the 64-bit arithmetic is unnecessary overhead on the common
path.

Split parse() into two phases:
- Bytes 0-3: uint32_t loop with native 32-bit shifts (0, 7, 14, 21)
- Bytes 4-9: noinline parse_wide_() with uint64_t, only for BLE
  addresses and other 64-bit fields

The code generator auto-detects which proto messages use int64/uint64/
sint64 fields and emits USE_API_VARINT64 conditionally. On non-BLE
configs, parse_wide_() and the 64-bit accessors (as_uint64, as_int64,
as_sint64) are compiled out entirely.

Saves ~40 bytes flash on non-BLE configs. Benchmark shows 25-50%
faster parsing for 1-4 byte varints (the common case).

esphome/components/api/api_pb2.h

@@ -3,6 +3,9 @@
 #pragma once
 
 #include "esphome/core/defines.h"
+#ifdef USE_BLUETOOTH_PROXY
+#define USE_API_VARINT64
+#endif
 #include "esphome/core/string_ref.h"
 
 #include "proto.h"

esphome/components/api/proto.cpp

@@ -7,6 +7,23 @@ namespace esphome::api {
 
 static const char *const TAG = "api.proto";
 
+#ifdef USE_API_VARINT64
+optional<ProtoVarInt> ProtoVarInt::parse_wide_(const uint8_t *buffer, uint32_t len, uint32_t *consumed,
+                                               uint32_t result32) {
+  uint64_t result64 = result32;
+  uint32_t limit = std::min(len, uint32_t(10));
+  for (uint32_t i = 4; i < limit; i++) {
+    uint8_t val = buffer[i];
+    result64 |= uint64_t(val & 0x7F) << (i * 7);
+    if ((val & 0x80) == 0) {
+      *consumed = i + 1;
+      return ProtoVarInt(result64);
+    }
+  }
+  return {};
+}
+#endif
+
 uint32_t ProtoDecodableMessage::count_repeated_field(const uint8_t *buffer, size_t length, uint32_t target_field_id) {
   uint32_t count = 0;
   const uint8_t *ptr = buffer;

esphome/components/api/proto.h

@@ -94,65 +94,60 @@ class ProtoVarInt {
   explicit ProtoVarInt(uint64_t value) : value_(value) {}
 
   static optional<ProtoVarInt> parse(const uint8_t *buffer, uint32_t len, uint32_t *consumed) {
-    if (len == 0) {
-      if (consumed != nullptr)
-        *consumed = 0;
-      return {};
-    }
-
-    // Most common case: single-byte varint (values 0-127)
-    if ((buffer[0] & 0x80) == 0) {
-      if (consumed != nullptr)
-        *consumed = 1;
-      return ProtoVarInt(buffer[0]);
-    }
-
-    // General case for multi-byte varints
-    // Since we know buffer[0]'s high bit is set, initialize with its value
-    uint64_t result = buffer[0] & 0x7F;
-    uint8_t bitpos = 7;
-
-    // A 64-bit varint is at most 10 bytes (ceil(64/7)). Reject overlong encodings
-    // to avoid undefined behavior from shifting uint64_t by >= 64 bits.
-    uint32_t max_len = std::min(len, uint32_t(10));
-
-    // Start from the second byte since we've already processed the first
-    for (uint32_t i = 1; i < max_len; i++) {
+#ifdef ESPHOME_DEBUG_API
+    assert(consumed != nullptr);
+#endif
+    // 32-bit phase: bytes 0-3 (shifts 0, 7, 14, 21 — all native on 32-bit platforms)
+    uint32_t result32 = 0;
+    uint32_t limit = std::min(len, uint32_t(4));
+    for (uint32_t i = 0; i < limit; i++) {
       uint8_t val = buffer[i];
-      result |= uint64_t(val & 0x7F) << uint64_t(bitpos);
-      bitpos += 7;
+      result32 |= uint32_t(val & 0x7F) << (i * 7);
       if ((val & 0x80) == 0) {
-        if (consumed != nullptr)
-          *consumed = i + 1;
-        return ProtoVarInt(result);
+        *consumed = i + 1;
+        return ProtoVarInt(result32);
       }
     }
-
-    if (consumed != nullptr)
-      *consumed = 0;
-    return {};  // Incomplete or invalid varint
+    // 64-bit phase for values > 28 bits (BLE addresses etc.)
+#ifdef USE_API_VARINT64
+    return parse_wide_(buffer, len, consumed, result32);
+#else
+    return {};
+#endif
   }
 
+#ifdef USE_API_VARINT64
+ protected:
+  /// Continue parsing varint bytes 4-9 with 64-bit arithmetic.
+  /// Separated to keep 64-bit shift code (__ashldi3 on 32-bit platforms) out of the common path.
+  static optional<ProtoVarInt> parse_wide_(const uint8_t *buffer, uint32_t len, uint32_t *consumed, uint32_t result32)
+      __attribute__((noinline));
+
+ public:
+#endif
+
   constexpr uint16_t as_uint16() const { return this->value_; }
   constexpr uint32_t as_uint32() const { return this->value_; }
-  constexpr uint64_t as_uint64() const { return this->value_; }
   constexpr bool as_bool() const { return this->value_; }
   constexpr int32_t as_int32() const {
     // Not ZigZag encoded
-    return static_cast<int32_t>(this->as_int64());
-  }
-  constexpr int64_t as_int64() const {
-    // Not ZigZag encoded
-    return static_cast<int64_t>(this->value_);
+    return static_cast<int32_t>(this->value_);
   }
   constexpr int32_t as_sint32() const {
     // with ZigZag encoding
     return decode_zigzag32(static_cast<uint32_t>(this->value_));
   }
+#ifdef USE_API_VARINT64
+  constexpr uint64_t as_uint64() const { return this->value_; }
+  constexpr int64_t as_int64() const {
+    // Not ZigZag encoded
+    return static_cast<int64_t>(this->value_);
+  }
   constexpr int64_t as_sint64() const {
     // with ZigZag encoding
     return decode_zigzag64(this->value_);
   }
+#endif
   /**
    * Encode the varint value to a pre-allocated buffer without bounds checking.
    *