Add NativeMap support

Summary:
This diff introduces `NativeMap`, a tagged representation of various `folly::F14FastMap` based specializations of `Value`.
In the `Protocol::Value` implementation, a map was always represented as `folly::F14FastMap<Value, Value>`, significantly increasing the memory use & reducing cache efficiency for anything other than the most complex types.

The set of specializations was chosen according to the most-commonly used set specializations as found in the meta codebase(s):
* `MapOf<primitive, primitive>`, for each primitive type, e.g. bool, i32, ..
* `MapOf<primitive, Object>`, for each primitive type, e.g. bool, i32, ..
* `MapOf<primitive, Value`, for each primitive type, e.g. bool, i32, ..

Lastly the fallback resolves to the default `Protocol::Value::map`, i.e. `MapOf<Value, Value>`, allowing any generic map structure at the highest relative cost.

Note: These specializations aren't set in stone & can be added/removed.

Reviewed By: thedavekwon

Differential Revision: D72358846

fbshipit-source-id: b018a3bed516906660d4467f13e1152be3c45b9e

Author: sadroeck

third-party/thrift/src/thrift/lib/cpp2/protocol/NativeObject-inl.h

@@ -116,6 +116,51 @@ NativeSet::Specialized<T>* NativeSet::if_type() noexcept {
   return std::get_if<Specialized<T>>(&kind_);
 }
 
+// ---- NativeMap ---- //
+
+template <typename... Args>
+NativeMap::NativeMap(MapOf<Args...>&& m) noexcept : kind_(std::move(m)) {}
+
+template <typename T>
+bool NativeMap::is_type() const noexcept {
+  static_assert(
+      detail::is_map_v<T> && !std::is_same_v<T, NativeMap>,
+      "NativeMap is always a map type");
+  return std::holds_alternative<Specialized<T>>(kind_);
+}
+
+template <typename T>
+const NativeMap::Specialized<T>& NativeMap::as_type() const {
+  static_assert(
+      detail::is_map_v<T> && !std::is_same_v<T, NativeMap>,
+      "NativeMap is always a map type");
+  return std::get<Specialized<T>>(kind_);
+}
+
+template <typename T>
+NativeMap::Specialized<T>& NativeMap::as_type() {
+  static_assert(
+      detail::is_map_v<T> && !std::is_same_v<T, NativeMap>,
+      "NativeMap is always a map type");
+  return std::get<Specialized<T>>(kind_);
+}
+
+template <typename T>
+const NativeMap::Specialized<T>* NativeMap::if_type() const noexcept {
+  static_assert(
+      detail::is_map_v<T> && !std::is_same_v<T, NativeMap>,
+      "NativeMap is always a map type");
+  return std::get_if<Specialized<T>>(&kind_);
+}
+
+template <typename T>
+NativeMap::Specialized<T>* NativeMap::if_type() noexcept {
+  static_assert(
+      detail::is_map_v<T> && !std::is_same_v<T, NativeMap>,
+      "NativeMap is always a map type");
+  return std::get_if<Specialized<T>>(&kind_);
+}
+
 // ---- Object ---- //
 
 template <typename... Args>