IEnumerable<IGrouping<'a>> something;

something.aggregate((result,next)=> result.GroupBy(x=> returnElementFromNext(x)))

IEnumerable<IGrouping<'a>>

IGrouping<'a>

IEnumerable<IGrouping<'a>> something;

                var arrayFirst = new[]
                {
                    new { bound = 1, value = "something on top" },
                    new { bound = 10, value = "on top too" },
                    new { bound = 30, value = "on top at end" }
                };

                var arraySlave = new[] {
                    new { bound = 2, value = "slaveOne" },
                    new { bound = 15, value = "second slave" },
                    new { bound = 37, value = "slave on end" }
                };

                var mainArray = new[] { arrayFirst, arraySlave }; //Вот этот парень.

    class Item
    {
        public int Id { get; set; }

        public int? ParentId { get; set; }

        public string Name { get; set; }
    }

    IEnumerable<Item> list = ...
 
    var tree = list
        .Aggregate(
            ((IEnumerable<(Item, Item[])>)(new(Item, Item[])[0]), list.ToLookup(p => p.ParentId)),
            (a, e) => (a.Item1.Concat(new[] { (e, a.Item2[e.Id].ToArray()) }), a.Item2))
        .Item1
        .Where(p => p.Item1.ParentId == null);

    
public class node 
    {

        public int row { get; set; }
        public String value { get; set; }     
        public node[] childs{get;set;}      
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace PIC_
{
    class nodeComparer : IEqualityComparer<node>
    {
        public bool Equals(node x, node y)
        {
            return x.row == y.row;
        }

        public int GetHashCode(node obj)
        {
            return obj.row.GetHashCode();
        }
    }
    public class node
    {

        public int row { get; set; }
        public String value { get; set; }
        public node[] childs { get; set; }
    }

    public static class treeBuilder
    {
        public static void build()
        {
            var arrayFirst = new[]
            {
                    new { row = 1, value = "something on top" },
                    new { row = 10, value = "on top too" },
                    new { row = 30, value = "on top at end" }
                };

            var arraySlave = new[] {
                    new { row = 2, value = "slaveOne" },
                    new { row = 15, value = "second slave" },
                    new { row = 37, value = "slave on end" }
                };

            var mainArray = new[] { arrayFirst, arraySlave }; //Вот этот парень.

            var finalTest = mainArray.Reverse().Select(x => x.Select(c => new node { row = c.row, value = c.value })
                            .OrderBy(c => c.row)
                            .AsEnumerable())
           .Aggregate((result, nextnode) => result.GroupBy(x => nextnode.Where(masterNode => masterNode.row < x.row)
                            .OrderByDescending(c => c.row).FirstOrDefault(), new nodeComparer())
                            .Select(x => new node { row = x.Key.row, value = x.Key.value, childs = x.ToArray() })
           );
        }
    }
}

Tuple<int,int,int>