einsum: double-fence each sub-World before destruction (incl. on exception unwind)

Add an inline RAII guard `FenceSubWorldsOnExit` to the generalized-
contraction path of einsum, declared right after the `worlds` vector so
it destructs *before* `worlds` (LIFO) and *after* AB/C. On normal exit
this is a final harmless drain; on exception unwind it drains any
`lazy_sync_children` tasks that ~DistArray scheduled via lazy_deleter
on sub-World taskqs before those sub-Worlds are torn down. Without
this, those tasks survive into the global ThreadPool past ~World, then
trip ~WorldObject's `World::exists(&world)` assertion when an enclosing
scope's fence runs them, masking the real exception with a cryptic
abort.

Two fences per sub-World are required: WorldGopInterface::fence_impl
runs `deferred_->do_cleanup()` only after its task-drain loop, so the
fresh lazy_sync_children tasks the destructors enqueue via lazy_sync
are left pending when the first fence returns; the second fence drains
them. (A single sub-World's ranks all call this collectively, so the
cross-rank lazy_sync handshake matches up correctly. The same trick
would not be safe inside the global fence_impl because main-world
peers have independent shared_ptr refcounts and need not reach the
same do_cleanup in lockstep.)

Author: evaleev

src/TiledArray/einsum/tiledarray.h

@@ -653,6 +653,39 @@ auto einsum(expressions::TsrExpr<ArrayA_> A, expressions::TsrExpr<ArrayB_> B,
     // dead World (e.g. while unwinding an exception thrown mid-contraction).
     std::vector<std::shared_ptr<World>> worlds;
 
+    // RAII fencer: on normal exit and (critically) on exception unwind,
+    // fence every live sub-World before it is destroyed. ~DistArray ->
+    // lazy_deleter calls world.gop.lazy_sync(...) which enqueues a
+    // lazy_sync_children task onto the sub-World's taskq; without a fence
+    // those tasks survive into the global ThreadPool past the sub-World's
+    // ~World, then trip ~WorldObject's `World::exists(&world)` assertion
+    // when some later fence (e.g. an enclosing scope's fence run during
+    // unwind) picks them up. Declared *after* `worlds` so it destructs
+    // *before* `worlds` (LIFO); destructs *after* AB/C so it sees the
+    // tasks they scheduled via lazy_deleter.
+    //
+    // Two fences per sub-World are needed: WorldGopInterface::fence_impl
+    // runs `deferred_->do_cleanup()` only after its task-drain loop, and
+    // the destructors that releases triggers (TA's lazy_deleter ->
+    // lazy_sync) schedule a fresh lazy_sync_children task on the world's
+    // taskq. That task is left pending when fence_impl returns; a second
+    // fence drains it. (Within a single sub-World all participating ranks
+    // call fence collectively, so the cross-rank lazy_sync handshake
+    // matches up correctly.)
+    struct FenceSubWorldsOnExit {
+      std::vector<std::shared_ptr<World>> &worlds_;
+      ~FenceSubWorldsOnExit() {
+        for (auto &w : worlds_) {
+          if (!w) continue;
+          try {
+            w->gop.fence();
+            w->gop.fence();
+          } catch (...) {
+          }
+        }
+      }
+    } fence_subworlds_on_exit{worlds};
+
     std::tuple<ArrayTerm<ArrayA>, ArrayTerm<ArrayB>> AB{{A.array(), a},
                                                         {B.array(), b}};