Cutting Sequence for N dimensions
Python, 226 bytes

Assumes the lists O and V are defined, as well as the time T, either an int or a float.

Try it online



s=lambda x:int(x/abs(x));r=range;f=lambda O,V,T:"".join(map(lambda t:t[1],sorted(sum([[((i-o)/v,"%+d"%(s(v)*c))for i in r((v&gt;0)-(v&lt;0)*(o==0),int((o+T*v)//1)+(v&gt;0),s(v))]for c,o,v in zip(r(len(O)),O,V)],[]),key=lambda t:t[0])))


The idea of the code is simple, first we loop over all coordinates, and for each coordinate we:


find where the first cut is, depending on the sign of v and the origin being 0 or not, the first cut might be at -1, 0 or 1;
find how far the ray goes in the time given with o + v*T (which then needs proper rounding to be an argument for the range function);
find the time t for which each successive cut occurs, by solving o + v*t = i iff t = (i - o)/v, for the successive integer values of i (this amounts to finding the time for which the ray crosses the hyperplane x_c = i);
sort everything by the time and drop the time, as it was just an auxiliary thing.


The code un-golfed:



# sign function, returns 1 for positive numbers and -1 for negative numbers
sgn = lambda x: int(x/abs(x))
l = []
# c is the coordinate we are in,
# o is the origin in this coordinate and v the velocity
for (c, o, v) in zip(range(len(O)), O, V):
    # find all the cuts for this coordinate
    sub_l = []
    # this is how far the ray goes, rounded to integers, in T seconds
    stop_at = int((o + T*v)//1) # if this is negative, //1 pushes the result away from 0
    if v &gt; 0:
        stop_at += 1
    # this is where the first cut occurs (depends on o == 0 and the sign of v)
    if v &gt; 0:
        start_at = 1
    elif o &gt; 0:
        start_at = 0
    else:
        start_at = -1
    for i in range(start_at, stop_at, sgn(v)):
        # this is the time at which the ray cuts the x_c = i hyperplane
        t = (i - o)/v
        # append the time of the cut and the signed axis
        sub_l.append((t, "%+d"%(sgn(v)*c)))
    l.append(sub_l)
print(l)
# flatten list
l = sum(l, [])
# order list by the time at which the cut occurs
l.sort(key = lambda tup: tup[0])
# remove the times, keep the coordinates
l = map(lambda tup: tup[1], l)
# join and print
print("".join(l))


Then we just need to note a couple of things, like I can save some bytes if I redefine r = range or if I assign start_at = (v&gt;0)-(v&lt;0)*(o==0) and stop_at = int((o+T*v)//1)+(v&gt;0). 

I don't feel this is properly golfed, I just wrote a program that works and then crammed everything together. Please feel free to give me some feedback.

I used a flatten from https://stackoverflow.com/a/952946/2828287 and getting the sign of a number from https://stackoverflow.com/a/2763445/2828287