refactor: use "if constexpr" in std::vector's Unserialize()

This gets rid of unnecessarily creating a temporary object T() to call
the right function.

src/serialize.h

@@ -650,8 +650,6 @@ template<typename Stream, unsigned int N, typename T> inline void Unserialize(St
  * vectors of unsigned char are a special case and are intended to be serialized as a single opaque blob.
  */
 template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v);
-template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, const unsigned char&);
-template<typename Stream, typename T, typename A, typename V> void Unserialize_impl(Stream& is, std::vector<T, A>& v, const V&);
 template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v);
 
 /**
@@ -802,35 +800,25 @@ void Serialize(Stream& os, const std::vector<T, A>& v)
 
 
 template <typename Stream, typename T, typename A>
-void Unserialize_impl(Stream& is, std::vector<T, A>& v, const unsigned char&)
+void Unserialize(Stream& is, std::vector<T, A>& v)
 {
+    if constexpr (std::is_same_v<T, unsigned char>) {
         // Limit size per read so bogus size value won't cause out of memory
         v.clear();
         unsigned int nSize = ReadCompactSize(is);
         unsigned int i = 0;
-    while (i < nSize)
-    {
+        while (i < nSize) {
             unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
             v.resize(i + blk);
             is.read(AsWritableBytes(Span{&v[i], blk}));
             i += blk;
         }
-}
-
-template<typename Stream, typename T, typename A, typename V>
-void Unserialize_impl(Stream& is, std::vector<T, A>& v, const V&)
-{
+    } else {
         Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
     }
-
-template<typename Stream, typename T, typename A>
-inline void Unserialize(Stream& is, std::vector<T, A>& v)
-{
-    Unserialize_impl(is, v, T());
 }
 
 
-
 /**
  * pair
  */