How can I distinguish the different "levels" of recursion?

I believe you have some faulty logic in your recursion, assuming that different "recursion levels" refer to tables within tables. To begin to debug, we simplify the problem by testing a simple case that just prints out what your recursion provides to the function to check if it is working as intended in the first place. As you can see, somthing is wrong.

--Function with test table
function tableRec(tab, func)
    if type(tab) ~= "table" then return end
    local level = 0;
    for i, v in pairs(tab) do
	    level = level + 1
	    func(i, v, level)
	    tableRec(v, func, level)
    end
end

--Test table. Contains tables for recursion and hardcoded recursion levels
local testTbl = {
    ["level"] = 0,
    ["Recursion1"] = {
	    ["level"] = 1,
	    ["Recursion2"] = {
		    ["level"] = 2,
		    ["Recursion3"] = {
			    ["level"] = 3
		    }
	    },
    }
}
tableRec(testTbl, function(index, value, level) 
    print(tostring(index).."\t"..tostring(value).."\t"..level) 
    end)

Output (Edited for Clarification):

--Format is (index, value, recursionlevel)
level	0	2
Recursion1 table: 00000176DFD522D0 1
    level	1	2
    Recursion2 table: 00000176DFD52550 1
        level	2	2
	    Recursion3 table: 00000176DFD51F60 1
		    level	3	1

As you can see, your function provides recursion levels that clearly don't match the hard-coded, correct values (The 2nd and 3rd printouts). This is because, in your function, you increment the level with each object found in the given table, not with each new recursion spawned. Also, the new level passed to tableRec is completely ignored

function tableRec(tab, func) --Level is never passed here!
    for i, v in pairs(tab) do 
	     level = level + 1 --This line increments level with each new object found in the table, not each new level.
	     func(i, v, level) 
	     tableRec(v, func, level) --Level is ignored in the new call!
     end 
 end

To fix this, we need to only increase the level when we pass a new level to a table. Here is the function, hopefully working as intended

function tableRec(tbl, func, level) --Add an OPTIONAL paremeter to be used in the recursion loop.
	--If we weren't passed a recursion level, assume we are starting a recursion loop and set to 0
	 if not level then level = 0 end
	
	--Add printouts for debugging. Also, use typeof - (it's more compatible with ROBLOX)
     if typeof(tbl) ~= "table" then warn("Passed table not a table!") return end 
     for i, v in pairs(tbl) do 
	    func(i, v, level) 
		if typeof(v) == "table" then --If we have found a table, call the recursive function on it!
			tableRec(v, func, level + 1) --Add one to the current level to indicate a new level of recursion
		end
     end 
 end

Output (With the same table as before):

level	0	0
Recursion1 table: 00000176E04896A0 0
	level	1	1
	Recursion2 table: 00000176E0488A70 1
	    level	2	2
		Recursion3 table: 00000176E04894C0 2
			level	3	3

As you can see, the calculated level now matches with the hard-coded one! All in all, recursion can be difficult to wrap your mind around at first, but becomes an incredibly powerful tool once you get it. Good luck!