I took the liberty of revisiting the source code of your dr_tensor
container and implementing a draft of the tensor container, making some
design changes to make it more flexible and lightweight.
Among other things, I believe that the implementation of the tensor
container should take inspiration from the specifications of some STL
containers, such as std::vector, and from the specification of std::mdspan
because they represent the real updates that the C++ language has had in
recent years. While the role of the tensor container should be to extend
the functionality of std::valarray by providing an interface for operating
on multidimensional arrays, the existence of the tensor container should
represent an evolution of std::valarray, an evolution that it was never
carried forward because the class stopped being actively supported from the
beginning. In this sense, if we succeed in carrying out the proposal and it
is approved by the committee, I hope that the tensor container will be more
successful than std::valarray and can be updated over time.
The class definition may be the following:

template <class T, class Extents, class LayoutPolicy = std::layout_right,
class ContainerPolicy = /* see-below */, class Alloc = std::allocator<T>>
class tensor;

The type T must meet the requirements of NumericType.
The requirements that are imposed on the elements depend on the actual
operations performed on the container. Generally, it is required that
element type meets the requirements of Erasable, but many member functions
impose stricter requirements. This container (but not its members) can be
instantiated with an incomplete element type if the allocator satisfies the
allocator completeness requirements.
The type Extents specifies number of dimensions, their sizes, and which are
known at compile time. Must be a specialization of std::extents.
The type LayoutPolicy specifies how to convert multidimensional index to
underlying 1D index (column-major 3D array, symmetric triangular 2D matrix,
etc) .
The type ContainerPolicy specifies how the elements in the container must
be accessed.
The type Alloc must meet the requirements of Allocator. The program is
ill-formed if Allocator::value_type is not the same as T.

using value_type = T;
using reference = value_type&;
using const_reference = const value_type&;
using pointer = std::allocator_traits<Alloc>::pointer;
using const_pointer = std::allocator_traits<Alloc>::const_pointer
using size_type = [ Unsigned integer type (usually std::size_t) ];
using difference_type = [ Signed integer type (usually std::ptrdiff_t) ];
using iterator = [ LegacyRandomAccessIterator, contiguous_iterator, and
ConstexprIterator to value_type ];
using const_iterator = [ LegacyRandomAccessIterator, contiguous_iterator,
and ConstexprIterator to const value_type ];
using reverse_iterator = reverse_iterator<iterator>;
using const_reverse_iterator = reverse_iterator<const_iterator>;
using extents_type = Extents;
using layout_type = LayoutPolicy;
using accessor_type = ContainerPolicy;
using allocator_type = Alloc;

constexpr tensor() noexcept(std::is_default_constructible_v<Alloc>);
[ Note: you cannot indicate the default constructor as noexcept (only
conditionally noexcept), because the standard does not guarantee that the
allocator's default constructor will not throw exceptions ]
constexpr explicit tensor(const allocator_type& a) noexcept;
constexpr explicit tensor(size_type n, const allocator_type& a =
allocator_type());
constexpr tensor(size_type n, const value_type& v, const allocator_type& a
= allocator_type());
constexpr tensor(const tensor& x);
constexpr tensor(const tensor& x, const allocator_type& a);
constexpr tensor(tensor&& x) noexcept;
constexpr tensor(tensor&& x, const allocator_type& a) noexcept;
[Note: it doesn't make sense to make noexcept conditional, because the
standard guarantees that the allocator's copy and move constructor doesn't
throw exceptions, and the container's move constructor doesn't have to do
any memory allocating operations.]
constexpr tensor(std::initializer_list<value_type> il, const
allocator_type& a = allocator_type());
template <class InputIter> constexpr tensor(InputIter first, InputIter
last, const allocator_type& a = allocator_type());
[ Note: this overload participates in overload resolution only if InputIt
satisfies LegacyInputIterator ]
template <class R> constexpr explicit tensor(std::from_range_t, R&& rg,
const allocator_type& a = allocator_type());
[ Note: this overload participates in overload resolution only if R
satisfies at least the std::ranges::input_range concept ]
constexpr ~tensor();
constexpr tensor& operator=(std::initializer_list<value_type> il);
constexpr tensor& operator=(const tensor& x);
constexpr tensor& operator=(tensor&& x)
noexcept(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value
|| std::allocator_traits<Allocator>::is_always_equal::value);
constexpr allocator_type get_allocator() const noexcept;
[ Note: set_allocator() was removed because changing the allocator doesn't
make much sense, also because, if
std::allocator_traits<Alloc>::is_always_equal::value is not true, it might
be necessary to deallocate already existing memory with the previous
allocator and re-allocate memory with the new allocator ]
[[nodiscard]] constexpr bool empty() const noexcept;
constexpr size_type size() const noexcept;
constexpr size_type capacity() const noexcept;
constexpr size_type max_size() const noexcept;
constexpr reference operator[](size_type ... indices);
constexpr const_reference operator[](size_type... indeces) const;
constexpr reference at(size_type ... indices);
constexpr const_reference at(size_type... indeces) const;
[ Note: if pos is not within the range of the container, an exception of
type std::out_of_range is thrown ]
constexpr swap(tensor& x)
noexcept(std::allocator_traits<Allocator>::propagate_on_container_swap::value
|| std::allocator_traits<Allocator>::is_always_equal::value);
void resize(size_type n);
void resize(size_type n, const value_type& v);

template <class T, class Extents, class LayoutPolicy, class
ContainerPolicy, class Alloc>
constexpr bool operator==(const tensor<T, Extents, LayoutPolicy,
ContainerPolicy, Alloc>& x, const tensor<T, Extents, LayoutPolicy,
ContainerPolicy, Alloc>& y);

template <class T, class Extents, class LayoutPolicy, class
ContainerPolicy, class Alloc>
constexpr auto operator<=>(const tensor<T, Extents, LayoutPolicy,
ContainerPolicy, Alloc>& x, const tensor<T, Extents, LayoutPolicy,
ContainerPolicy, Alloc>& y);

For the moment, we must work on custom constructors for std::mdspan of
others. The most important thing is creating few overloaded constructors,
that do not cause ambiguity with the already-existing overloaded
constructors. I omitted all the member overloaded operators to perform
Linear Algebra operations, since they can be easily found in the
implementation of std::valarray. Other member functions to perform more
specific operations might be introduced in the future. All non-member
overloaded operators to perform Linear Algebra operations use the member
overloaded operators under the hood.
Furthermore, we should think more about how to integrate the std::mdspan
class, taking from it only the interface to manage multidimensional arrays,
and some STL containers, taking from them the allocator-aware interface.