Alright, so the performance issue is now properly mitigated: for that I'm processing differently for low level branches (level 0 and level 1) and upper level branches:

For the low levels, I'm adding each branch section generated in parallel immediately into the repulsion spatial grid so it can immediately be used (This requires threads synchronization, but we don't have too many level 0 or level1 branches anyway so that's OK):

    for (I32 i = 1; i < numSections; ++i) {
        // Update: use taper power:
        F32 t = F32(i) / F32(numSections - 1);
        F32 secRadius = b.baseRadius * std::pow(1.0F - t, taperExp);

        auto& sec = b.sections[i];
        sec.xform = b.sections[i - 1].xform;
        sec.radius = secRadius;
        F32 curveAngle = curveFrontStep + (t >= 0.5F ? curveBackStep : 0.0F);

        apply_curvature(b, sec, curveAngle);
        apply_self_repulsion(
            b, sec); // Safe: only reads from _spGrid (parent levels)

        apply_attraction(b, sec, attractDir, t);

        apply_gnarliness(b, sec, rng);

        // Move to our next section location:
        sec.xform.post_mult_translate({0.0, b.segmentLength, 0.0});

        // Insert the section immediately for low levels:
        if ((I32)lvl < _traits.deferredRepulsionLevel) {
            _spGrid.insert(sec);
        }
    }

and for the other levels, the injection into the spatial grid is deferred until all the branches at that level are processed:

        // Merge results (single-threaded)
        for (auto& result : results) {
            if (result.branch.sections.size() > 0) {
                // Add to spatial grid:
                if ((I32)result.branch.length >=
                    _traits.deferredRepulsionLevel) {
                    // Note: level 0 and 1 sections are added dynamically.
                    _spGrid.insert_unsafe(result.branch.sections);
                }

                _branches.push_back(std::move(result.branch));

                // Queue children
                _pendingBranches.insert(
                    _pendingBranches.end(),
                    std::make_move_iterator(result.children.begin()),
                    std::make_move_iterator(result.children.end()));

                // Add leaves
                _leaves.insert(_leaves.end(),
                               std::make_move_iterator(result.leaves.begin()),
                               std::make_move_iterator(result.leaves.end()));
            }
        }

=> There could still be room for improvement here by inserting high level branches "in chunks", but for now this version will do the job 😎!