Because it's simple & efficient.
When you have only one stack, you don't have to do anything for your stack memory management. All the things you have to do is allocate one big chunk of memory before the execution. it's as same as native codes works. you can not make it simpler than that.
Second reason is efficiency of execution. Because your stack is just another big chunk of memory, it may reside in cpu cache most of times. It's good thing 'cause it's super fast. Furthermore because of the nature of stack data structure, memory access pattern would be consistent. So it's super cpu firendly. Most of cpu doesn't like random access so you can expect your vm runs much faster than the other architecture. And you only need two integer variable (probably on the cpu regsiter) to track the use of your stack.
"When we reach end, we pop the top of the stack, assuming it's the line number we should return to But it isn't, the line number to return to is buried underneath. How should end know about this?"
In a first place, there is no line number in assembly. It's memory address of code section of your program. before call funcA, usually argument pushed on to the stack. Then, it save the register called "base pointer register". Then, return address of funcA is pushed on to stack to save where to execute when the control returned from the function. call instruction usually do this (save ebp) and jump to the address of funcA.
What's happening at the end of funcA is something like this.
mov __some_register__, __stack_top(return value of function)__;
pop; (pop out return value)
mov __stack_pointer__, __base_pointer__ (deallocate local variable)
mov __base_pointer_register__, __stack_top__ (restore saved base-pointer)
mov __program_counter__, __stack_top__ (stored return adress before call)
push __some_register__ (restore return value on top of stack)
(usually, these procedure is packed as "ret" instruction)
So answer is, "call" instruction stores necessary information to recover the state of the program before jump into the function. Usually base pointer and return address. So when function "returns", you can pop out those information from the stack by "ret" instruction. In addition to it, "stack machine" needs some register to temporarily store some information (something like return value) so that program can use return value after control back to callee.
Usually, if your computation in "funcA" is somehow legit, how long the computation is, it going to left only one value on the stack when one "statement" is done. Therefore you can expect original state of the stack is recovered when you return from "funcA" (stack pointer must be in original position plus one, because return value appears on stack top). If funcA messes up the stack when it's done, you can assume design of your vm is not legit or the compilation of funcA must be corrupted.
Both of "register machine" and "stack machine" has similar call-stack structure in general. So if you don't understand what "base pointer" or "stack poitner" for, do some more research on call-stack. Actually, it's a lot easier than you think, so you can get it soon I think.