Ok, I figured out how to anonymize it a bit.
Function A and B do different things, but part of B's return value is identical to all of the return value of A.
Function A calls Function 1 to get its return value. Function B calls Function 1a to get that same part of its return value.
Functions 1 and 1a are identical, but they're not the same function. They even appear one after the other in the source.
I need a couple of features added to Function A. The Loony Programmer adds them to Function 1a, doesn't test it, says it works and its done and we can release.
So I need to troubleshoot why it doesn't actually work when it's actually tested, and I find some interesting things. Functions 1 and 1a both call Function 2 to format the return value. Function 2 takes 5 parameters and returns them as a keyed array, with 3 of those parameters unmodified. Functions 1 and 1a declare and assign a value to a global variable right before calling Function 2. Functions 1 and 1a give as the 5 parameters 5 elements of a keyed array, and the keys are identical to the keys that Function 2 returns.
Now then, Function 2 calls Function 3, which uses that previously mentioned global variable in order to call Function 4 and return it's return value back to Function 2 which inserts it as #4 in the keyed array. Function 2 calls Function I for parameter 5.
So, I remove Function 1 and redirect Function A to call Function 1a instead and comment out FUnction 1. (I'll leave out the part about how 1 and 1a were mysteriously *not* interchangeable even though they were identical because that still blows my mind).
Then, since I was trying to get Function A to return the new features that were added and it wasn't, I eliminated Function 2 by just making an array() call. For paramter 4 of the array, since I was now in the function in scope that initialized the global variable previously used by Function 3, I eliminated Function 3 entirely and called Function 4 directly in my array() call. For parameter #5 I called Function I directly because it was a benign and useful function.
Total lines eliminated: I didn't count, but at least 30, probably closer to 50.
Levels of complexity eliminated: 4
Lines added to Function 1a: 4
Factoring complete, modularization in that part of the code achieved.
So the Loony Programmer looks at it and says "Long functions are ugly and you made a long function longer. I wrote all those functions so that Function 1a wouldn't get needlessly long." (Evidently the Loony Programmer is still unaware that Functions 1 and 1a were identical and he added the features I needed to a different context so I couldn't use them)
Hence the poll.
Edit: I think my daughter would have done better. It is only php and she is almost in first grade, after all.