expressions: address PR review (Phase E)

- GeneralRepermuteOp: store/apply only the OUTER result-layout permutation.
  The streaming re-permute wrapper exists to reorder a general product's
  outer (result) layout; inner (within-cell) permutation of ToT results is
  handled separately (init_struct_general / implicit_permute_inner_). Using
  the full bipartite perm_ would also permute inner cells -- a no-op when the
  inner perm is identity, but a latent double-apply if an inner perm is ever
  deferred to a downstream op. Pass outer(perm_) into the op; the host
  UnaryEvalImpl still receives full perm_ for ordinal/trange remap.
- MultEngine down-pass: materialize each child demand as a named lvalue
  before preferred_layout(), which returns a reference to its argument for
  leaf/binary engines -- avoids a needlessly fragile bind-to-temporary.

Author: evaleev

src/TiledArray/expressions/cont_engine.h

@@ -851,7 +851,12 @@ class ContEngine : public BinaryEngine<Derived> {
     typedef value_type result_type;
     typedef value_type argument_type;
     static constexpr bool is_consumable = false;
-    BipartitePermutation perm;
+    /// Only the *outer* (result-layout) permutation is applied here; inner
+    /// (within-cell) permutation of tensor-of-tensor results is handled
+    /// separately (see init_struct_general / implicit_permute_inner_), so this
+    /// op stores a plain outer Permutation to avoid accidentally permuting
+    /// inner contents.
+    Permutation perm;
     /// false when the consumer fuses the permutation into its own operation
     /// (implicit permute, e.g. a transposed GEMM): then only the tile
     /// ordinals/trange are remapped (by the host UnaryEvalImpl) and the tile
@@ -917,7 +922,7 @@ class ContEngine : public BinaryEngine<Derived> {
     std::shared_ptr<repermute_impl_type> wrapper =
         std::make_shared<repermute_impl_type>(
             canonical, *world_, trange_, shape_, pmap_, perm_,
-            GeneralRepermuteOp{perm_, !this->implicit_permute_outer_});
+            GeneralRepermuteOp{outer(perm_), !this->implicit_permute_outer_});
     return dist_eval_type(wrapper);
   }
 

src/TiledArray/expressions/mult_engine.h

@@ -328,11 +328,18 @@ class MultEngine : public ContEngine<MultEngine<Left, Right, Result>> {
       // each child dictates the ORDER of its demand (preferred_layout): a
       // product child reorders to its canonical (h, eA, eB) layout -- a
       // general product cannot host a result permutation, and contraction
-      // consumers absorb any child layout via the GEMM transpose forms
-      BinaryEngine_::left_.init_indices(BinaryEngine_::left_.preferred_layout(
-          bipartite_demand(avail_l, avail_r, target_indices)));
-      BinaryEngine_::right_.init_indices(BinaryEngine_::right_.preferred_layout(
-          bipartite_demand(avail_r, avail_l, target_indices)));
+      // consumers absorb any child layout via the GEMM transpose forms.
+      // Materialize the demands as named lvalues: some preferred_layout()
+      // overloads (leaf/binary/unary) return a reference to their argument, so
+      // binding that to a temporary demand would be needlessly fragile.
+      const BipartiteIndexList left_demand =
+          bipartite_demand(avail_l, avail_r, target_indices);
+      const BipartiteIndexList right_demand =
+          bipartite_demand(avail_r, avail_l, target_indices);
+      BinaryEngine_::left_.init_indices(
+          BinaryEngine_::left_.preferred_layout(left_demand));
+      BinaryEngine_::right_.init_indices(
+          BinaryEngine_::right_.preferred_layout(right_demand));
     }
 
     this->product_type_ = compute_product_type(