Const wrapper for iterator
I don't think your specialization is doing what you think it's doing. https://godbolt.org/z/Gfh7sv
You don't want ConstWrapper&lt;ConstWrapper&lt;Iterator&gt;&gt; to inherit from ConstWrapper&lt;Iterator&gt;; that would mean that a CW&lt;CW&lt;I&gt;&gt; &quot;is-a-kind-of&quot; CW&lt;I&gt;, which isn't true. You don't want an inheritance relationship here. What you want is simply for specializations of Storage to not wrap DataIterators that happen to be specializations of ConstWrapper already. The way you do that is with an extra layer of alias indirection:
template&lt;class T&gt; struct maybe_constwrap { using type = ConstWrapper&lt;T&gt;; };
template&lt;class U&gt; struct maybe_constwrap&lt;ConstWrapper&lt;U&gt;&gt; { using type = ConstWrapper&lt;U&gt;; };

template&lt;class Size, typename DataIterator&gt;
class Storage : public Size {
public:
    using iterator = DataIterator;
    using const_iterator = typename maybe_constwrap&lt;DataIterator&gt;::type;
    ~~~
};

Now, if DataIterator is already a ConstWrapper, then both iterator and const_iterator will be literally the same type... which is what you want.

Your MakeConst seems to be predicated on the dubious idea that const _Bit_reference is not going to be assignable-to. That's likely to change in C++23. See https://stackoverflow.com/questions/63412623/should-c20-stdrangessort-not-need-to-support-stdvectorbool for some context.

You repeat some metaprogramming in the return types of operator* and operator[]. They should just return the type reference which you have already computed above.
reference operator*() const { return *it_; }

Incidentally, I'm changing your data member's name from iterator to it_, because I suspect it is a terrible idea, Concepts-wise, to have a container-ish class type with a member named iterator which member is (A) not public, and (B) not a type.

Your operator!= should probably use the hidden friend idiom:
friend bool operator==(ConstWrapper a, ConstWrapper b) { return a.it_ == b.it_; }
friend bool operator!=(ConstWrapper a, ConstWrapper b) { return a.it_ != b.it_; }

In C++20 you could theoretically omit operator!= and provide operator== only. I don't know yet if that's a good idea.
Passing ConstWrapper by value should be fine, because it holds only an iterator, and iterators are cheap to copy.