arena: support inner result permutation for ToT x scalar Scale contraction

A mixed inner-Scale product (Tensor<ArenaTensor> ToT x plain Tensor ->
ToT) under an outer Contraction with a non-identity inner *result*
permutation crashed in ArenaTensor::axpy_to(other, factor, perm), which
rejects in-place permutation of view cells.

The Scale path pushed the inner perm onto the per-cell op (via the
fallback axpy_to(..., perm)) and dropped it from total_perm, while
make_contraction_arena_plan bailed on any non-identity inner perm --
leaving the view result cell both unshaped and asked to permute itself.

Mirror the inner-Contraction view handling instead: for view (arena)
result cells, carry the full perm in total_perm so op_'s post-processing
permute applies the inner result perm as a slab-level rewrite, and pass
an identity inner perm to make_contraction_arena_plan so it builds the
plan (pre-shaping result cells unpermuted) and selects the perm-free
fused scale op. Owning inner cells keep applying the inner perm in the
per-cell scale op (outer-only total_perm), unchanged.

Author: evaleev

src/TiledArray/expressions/cont_engine.h

@@ -305,9 +305,18 @@ class ContEngine : public BinaryEngine<Derived> {
           // this->product_type() is Tensor::Contraction, and,
           // this->implicit_permute_inner_ is false
 
-          return this->inner_product_type() == TensorProduct::Scale
-                     ? BipartitePermutation(outer(this->perm_))
-                     : this->perm_;
+          if (this->inner_product_type() == TensorProduct::Scale) {
+            // Owning inner cells apply the inner result permutation in the
+            // per-cell scale op, so they carry only the outer perm here. View
+            // (arena) cells instead use a perm-free per-cell op + an unpermuted
+            // arena plan and rely on op_'s post-processing permute for the
+            // inner perm -- so they carry the full perm, like inner
+            // Contraction.
+            if constexpr (!TiledArray::is_tensor_view_v<
+                              result_tile_element_type>)
+              return BipartitePermutation(outer(this->perm_));
+          }
+          return this->perm_;
         };
 
         auto total_perm = make_total_perm();
@@ -341,9 +350,18 @@ class ContEngine : public BinaryEngine<Derived> {
           // this->product_type() is Tensor::Contraction, and,
           // this->implicit_permute_inner_ is false
 
-          return this->inner_product_type() == TensorProduct::Scale
-                     ? BipartitePermutation(outer(this->perm_))
-                     : this->perm_;
+          if (this->inner_product_type() == TensorProduct::Scale) {
+            // Owning inner cells apply the inner result permutation in the
+            // per-cell scale op, so they carry only the outer perm here. View
+            // (arena) cells instead use a perm-free per-cell op + an unpermuted
+            // arena plan and rely on op_'s post-processing permute for the
+            // inner perm -- so they carry the full perm, like inner
+            // Contraction.
+            if constexpr (!TiledArray::is_tensor_view_v<
+                              result_tile_element_type>)
+              return BipartitePermutation(outer(this->perm_));
+          }
+          return this->perm_;
         };
 
         auto total_perm = make_total_perm();
@@ -949,10 +967,16 @@ class ContEngine : public BinaryEngine<Derived> {
                   result_tile_type, left_tile_type, right_tile_type>;
           if constexpr (arena_eligible_scale) {
             if (this->product_type() == TensorProduct::Contraction) {
+              // Pass an identity inner perm: a non-identity inner *result*
+              // permutation is applied downstream by op_'s post-processing
+              // permute (carried in make_total_perm for view cells), not by
+              // the per-cell op -- so the plan must not bail on it. The plan
+              // pre-shapes result cells in the unpermuted (operand) inner
+              // layout; the perm-free fused scale op accumulates into them.
               this->arena_plan_ =
                   TiledArray::detail::make_contraction_arena_plan<
                       result_tile_type, left_tile_type, right_tile_type>(
-                      kind, std::nullopt, inner(this->perm_));
+                      kind, std::nullopt, Permutation{});
             }
           }
           // Fallback per-element op for the scale inner-product when no