Using a function within a function
You've hit upon one of the most important issues in embedded programming - something that separates novices from more advanced programmers: blocking vs. non-blocking. 

Basic Arduino programs are like scripts that just repeat over and over: do step 1, do step 2, do step three, go back to 1, etc. With script-style thinking, to generate any timing you have to insert it as a step: Do step 1, wait 10ms, do Step 2, etc. The issue that you've seen is that while the Arduino is waiting nothing else can happen - this is called a blocking delay. Blocking is used in other situations as well. If, for example, you're waiting for a a serial byte to arrive, many libraries will just sit and watch the UART receive register until something arrives - and do nothing else until it does. Generally, libraries like this will have a timeout feature - if no data arrives in X milliseconds they'll stop and report no data. Blocking is used often on larger computers with operating systems but it's less of an issue. In that situation you can have multiple threads such that when one thread is waiting on UART data, the operating system will suspend that task and let another run while it waits. Embedded systems without an operating system (like the Arduino) need a library or other code to generate a non-blocking delay in a different fashion. Sadly, the Arduino doesn't have this ability built-in - you have to develop it yourself or find a library that implements it (as mpflaga suggested).

Implementing a non-blocking delay yourself is not a one-step process. It's not a matter of switching out one function call for another or changing a setting in the GUI. The entire architecture of your program needs to be changed to support it. 

Generally you'll use a timer which will interrupt at a predefined rate - usually 1ms is good for most applications. There will be a global integer that keeps track of elapsed time - how many milliseconds have passed since your program starts up (i.e., how many times the timer interrupt has been executed). Whenever you want a function to execute periodically instead of a delay you'll have a variable that keeps track of the last time index that it happened at and you'll query the current elapsed time. If the difference between is equal to the period you want the function to be called then you call it. Otherwise, you do nothing. In this paradigm you can't use any delay statements in your program. Any delay statements will throw off your timing.

For your application, it looks like you want to step your motors every 5ms, so that would be your time period. You'll have to keep track of what state each of the motors is in so you know what inputs to apply to them next. You can keep track of this in your step_one and step_two functions with function static variables and you can use a switch case to handle each state. In each state you'll set the inputs to the stepper motor and then assign the state variable to the next state: 0->1, 1->2, 2->3, 3->0

Eventually, you can modify the step_one and step_two functions to take a direction argument so you can move the motors in both directions or hold them still.