GH-49720: [C++] Optimize base64_decode validation using lookup table (#49748)

### Rationale for this change

The current implementation of `base64_decode` validates characters using `std::string::find` for each byte, which introduces unnecessary overhead due to repeated linear searches.

This change replaces those lookups with a precomputed 256-entry lookup table, enabling constant-time validation and value lookup per character.

### What changes are included in this PR?

- Introduced a static lookup table (`kBase64Lookup`) to map base64 characters to their corresponding values
- Replaced `std::string::find` with constant-time table lookup for character validation

### Are these changes tested?

Yes. Existing base64 decoding behavior remains unchanged and continues to pass all current tests. This change is a performance optimization and does not alter functional output.

### Are there any user-facing changes?

No. 

This change is internal and does not affect public APIs.

* GitHub Issue: #49720

Authored-by: Aaditya Srinivasan <aadityasri03@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>

Author: Reranko05

cpp/src/arrow/vendored/base64.cpp

@@ -30,16 +30,29 @@
 */
 
 #include "arrow/util/base64.h"
+#include <array>
+#include <cstdint>
 #include <iostream>
 
 namespace arrow {
 namespace util {
 
-static const std::string base64_chars =
+constexpr std::string_view base64_chars =
              "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
              "abcdefghijklmnopqrstuvwxyz"
              "0123456789+/";
 
+static const std::array<int8_t, 256> kBase64Lookup = [] {
+  std::array<int8_t, 256> table{};
+  table.fill(-1);
+
+  for (size_t i = 0; i < base64_chars.size(); ++i) {
+    table[static_cast<uint8_t>(base64_chars[i])] = static_cast<int8_t>(i);
+  }
+
+  return table;
+}();
+
 static std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
   std::string ret;
   int i = 0;
@@ -119,22 +132,18 @@ Result<std::string> base64_decode(std::string_view encoded_string) {
         return Status::Invalid("Invalid base64 input: padding in wrong position");
       }
 
-      if (base64_chars.find(c) == std::string::npos) {
+      int8_t val = kBase64Lookup[static_cast<uint8_t>(c)];
+
+      if (val == -1) {
         return Status::Invalid("Invalid base64 input: character is not valid base64 character");
       }
 
-      char_array_4[i++] = c;
+      char_array_4[i++] = val;
     }
 
     in_++;
 
     if (i == 4) {
-      for (i = 0; i < 4; i++) {
-        if (char_array_4[i] != 0) {
-          char_array_4[i] = base64_chars.find(char_array_4[i]) & 0xff;
-        }
-      }
-
       char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
       char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
       char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];