Add default constructurs to `filter_iterator_impl` and `filter_iterator_impl`.

[massberg]

Summary

Bases of reverse_iterator must be default-constructible. This is enforced when using libstdc++-12 plus C++20.

[ilya-biryukov]

Slight NIT: we might want to initialize End and iterator_adaptor_base::I with WrappedIteratorT End = WrappedIteratorT() to avoid uninitialized data members when WrappedIteratorT is a pointer.
This does not happen in practice right now, but if someone actually starts using this constructor in the future, we will at least not have UB.

llvm/include/llvm/ADT/STLExtras.h

protected:
   WrappedIteratorT End;
   PredicateT Pred;
 
   void findNextValid() {
     while (this->I != End && !Pred(*this->I))
       BaseT::operator++();
   }
 
+  filter_iterator_base() = default;
+
   // Construct the iterator. The begin iterator needs to know where the end
   // is, so that it can properly stop when it gets there. The end iterator only
   // needs the predicate to support bidirectional iteration.
   filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
       : BaseT(Begin), End(End), Pred(Pred) {
     findNextValid();
   }

 };
 
 /// Specialization of filter_iterator_base for forward iteration only.
 template <typename WrappedIteratorT, typename PredicateT,
           typename IterTag = std::forward_iterator_tag>
 class filter_iterator_impl
     : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
 public:
+  filter_iterator_impl() = default;
+
   filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
       : filter_iterator_impl::filter_iterator_base(Begin, End, Pred) {}
 };
 
 /// Specialization of filter_iterator_base for bidirectional iteration.
 template <typename WrappedIteratorT, typename PredicateT>
 class filter_iterator_impl<WrappedIteratorT, PredicateT,
                            std::bidirectional_iterator_tag>
     : public filter_iterator_base<WrappedIteratorT, PredicateT,
                                   std::bidirectional_iterator_tag> {
   using BaseT = typename filter_iterator_impl::filter_iterator_base;
 
   void findPrevValid() {
     while (!this->Pred(*this->I))
       BaseT::operator--();
   }
 
 public:
   using BaseT::operator--;
 
+  filter_iterator_impl() = default;
+
   filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
                        PredicateT Pred)
       : BaseT(Begin, End, Pred) {}
 
   filter_iterator_impl &operator--() {
     BaseT::operator--();
     findPrevValid();
     return *this;