Recursive function goes in never ending loop

Table.Join with the LeftHash algorithm seems to work a lot faster.

Actually NestedJoin works faster, had to correct the query.

(c_list as list, p_list as list) =>
let
    Source = 
    Table.AddIndexColumn(
        Table.TransformColumnTypes(
            Table.FromRows(
                List.Zip({c_list,p_list}), 
                {"c", "p"}
            ),
            {
                {"c", type text},
                {"p", type text}
            }
        )
        , "path_index_column"
    ),
    parent_table = Table.AddKey(Table.Buffer(Table.SelectRows(Source, each [p] <> null)), {"c"},true),
    add_path_col = Table.RemoveColumns(Table.AddColumn(Source,"path",each {[c]}), "p"),
    fnPath = 
        (tbl as table) => 
        let
            //join = Table.Join(tbl,"c",Table.PrefixColumns(parent_table,"n"),"n.c", JoinKind.LeftOuter, 3),
            //remove_c = Table.RemoveColumns(join, {"c","n.c", "n.path_index_column"}),
            //before_update_path = Table.RenameColumns(remove_c, {{"n.p", "c"}, {"path","old_path"}}),
            join = Table.NestedJoin(tbl,"c",parent_table,"c", "merged", JoinKind.LeftOuter),
            remove_c = Table.RemoveColumns(join, {"c"}),
            before_update_path = Table.RenameColumns(Table.ExpandTableColumn(remove_c, "merged", {"p"}, {"c"}),{"path","old_path"}),
            update_path = Table.Buffer(Table.AddColumn(before_update_path, "path", each if [c] <> null then [old_path] & {[c]} else [old_path])),
            //update_path = Table.ReplaceValue(before_update_path, each [path], each if [c] <> null then [path] & {[c]} else [path], Replacer.ReplaceValue, {"path"}),
            new_child = update_path[c],
            old_child = join[c],
            final = 
                if List.NonNullCount(new_child) < List.NonNullCount(old_child)
                    then @ fnPath(Table.RemoveColumns(update_path, "old_path"))
                else if List.NonNullCount(new_child) = 0
                    then                     
                        Table.SelectColumns(
                            Table.TransformColumns(
                                Table.AddColumn(
                                    Table.SelectColumns(update_path,{"path_index_column","path"}),
                                    "child",
                                    each [path]{0}
                                ), 
                                {"path", each Text.Combine(_, ",")}
                            ),
                            {"path_index_column","child","path"}
                        )
                else if 
                    List.Transform(
                        Table.SelectRows(update_path, each [c] <> null)[path], 
                        List.Distinct
                    ) 
                    <> 
                    List.Transform(
                        Table.SelectRows(update_path, each [c] <> null)[old_path],
                        List.Distinct
                    )
                // the condition above checks for circular relationships 
                    then @ fnPath(Table.RemoveColumns(update_path, "old_path"))
                else 
                    Table.SelectColumns(
                        Table.TransformColumns(
                            Table.AddColumn(
                                Table.SelectColumns(update_path,{"path_index_column","path"}),
                                "child",
                                each [path]{0}
                            ), 
                            {"path", each Text.Combine(_, ",")}
                        ),
                        {"path_index_column","child","path"}
                    )
                    
        in
            final,
    output = fnPath(add_path_col)
//        Table.FromRows(
 //           List.Zip({c_list,fnPath(add_path_col)}),
  //          {"child_column","path_column"}
  //      )
in
    output

will you be able to provide some sample data including ragged branches and orphans?

Alternatively you could do this in DAX with the built-in PATH function.