summa: address review comments on the 3-d batched grid

- contraction_eval: clamp the SUMMA step-task pipeline depth to my_steps()
  (this rank's group's step count) instead of nsteps_. In the 3-d
  (proc_h_ > 1) case my_steps() < nsteps_, so clamping to nsteps_
  pre-spawned surplus step tasks that all resolved to the terminating
  step (k_ == nsteps_). No-op for the 2-d path (my_slabs_ == nh_).

- cont_engine: keep proc_h_stride_ == 0 for the ungrouped 2-d case
  (proc_h_ == 1), matching the field's documented invariant; only the
  grouped (proc_h_ > 1) grid uses P / proc_h_.

- general_product test: correct the distributed suite header comment --
  dist_inner_node_thc validates against explicit binary intermediates,
  not the legacy einsum oracle.

Author: evaleev

src/TiledArray/dist_eval/contraction_eval.h

@@ -1515,8 +1515,12 @@ class Summa
 
     template <typename Derived>
     void make_next_step_tasks(Derived* task, ordinal_type depth) {
-      // Set the depth to be no greater than the maximum number steps
-      if (depth > owner_->nsteps_) depth = owner_->nsteps_;
+      // Set the depth to be no greater than the number of SUMMA steps this
+      // rank's group actually executes. In the 2-d (proc_h_ == 1) case this is
+      // nsteps_ (my_slabs_ == nh_); in the 3-d (proc_h_ > 1) case my_steps() <
+      // nsteps_, and clamping to nsteps_ would pre-spawn surplus step tasks
+      // that all resolve to the terminating step (k_ == nsteps_).
+      if (depth > owner_->my_steps()) depth = owner_->my_steps();
 
       // Spawn n=depth step tasks
       for (; depth > 0ul; --depth) {

src/TiledArray/expressions/cont_engine.h

@@ -874,7 +874,10 @@ class ContEngine : public BinaryEngine<Derived> {
         proc_h_ = std::min<size_type>(n_slabs_,
                                       std::max<size_type>(1ul, P / p2d_cap));
       }
-      proc_h_stride_ = P / proc_h_;
+      // keep the invariant proc_h_ == 1 => proc_h_stride_ == 0 (the ungrouped
+      // 2-d case) so downstream logic can key off either field; for grouped
+      // grids it is the per-plane world-rank count P / proc_h_.
+      proc_h_stride_ = (proc_h_ == 1ul) ? 0ul : P / proc_h_;
 
       if (proc_h_ == 1ul) {
         // Construct the per-slab process grid over the whole world.

tests/general_product.cpp

@@ -1350,8 +1350,12 @@ BOOST_AUTO_TEST_SUITE_END()
 // + np=1 evaluation), this suite carries NO label, so the CI harness runs it
 // at BOTH np=1 and np=2 (see tests/CMakeLists.txt: np-1 excludes @distributed,
 // np-2 excludes @serial). It exercises the batched Summa across ranks -- a
-// path the serial suite never covered. Each case differential-tests the
-// expression route against the legacy sub-World einsum oracle.
+// path the serial suite never covered. Most cases differential-test the
+// expression route against the legacy sub-World einsum oracle; the exception
+// is dist_inner_node_thc, which checks a single fused expression against a
+// reference built from explicit binary intermediates (the same expression
+// machinery), validating that nested general products at inner nodes agree
+// with the step-by-step evaluation.
 //
 // Most cases evaluate via the ordinary 2-d (proc_h == 1) batched Summa;
 // dist_no_externals_3d_grid exercises the 3-d (proc_h > 1) grid, where the