I am somewhat unfamiliar with the newer path instructions.
Although there may be much better ways, if you have simple linear path, which isn't in a loop and you just want the entity to walk the path in numerical node order:
(These are just untested, inadequate, flawed '5 min examples'. They may not be helpful.)
Code:

---

define _node, skill22;
define _nodeDir, skill23;
define _nodePrev, skill24;
define _nodeCount, skill25;

define pathScanRange, 1000;
define nodeHitDist, 3;
define relMoveSpeed, 5;

var temp2[3];
/************************************
	aPathWalker0

*************************************/
action aPathWalker0 {
	path_scan(me, my.x, my.pan, vector(360, 180, pathScanRange);
	my._node = 1;
	// find the closest node(added as an example only;
	// path_scan already returns the closest node)
	// count the nodes (just an example; not really used)
	var dist0; dist0 = 99999; 
	var dist1; dist1 = 0;
	var node0;  node0 = 1;
	while(path_getnode(me, my._node, temp, null)) {
		my._node += 1;
		dist1 = vec_dist(my.x, temp);
		if (dist1 < dist0) {
			dist0 = dist1;
			node0 = my._node;
		}
	}
	my._nodeCount = my._node - 1;
	if (my._nodeCount <= 1) { return; }	// only for greater than 1 node
	my._node = node0;		//the closest node
	my._nodeDir = 1;			//default to +1 walking
	my._nodePrev = 0;
	while(me != null) {
		if (path_getnode(me, my._node, temp, null)) {
			//
		} else {//over step
			my._nodeDir = 0 - my._nodeDir; 	//reverse nodeDir
			my._node += my._nodeDir * 2;
			path_getnode(me, my._node, temp, null);
		}
		temp.z =  my.z;
		if (vec_dist(temp, my.x) <= nodeHitDist) {
			my._nodePrev = my._node;
			my._node += my._nodeDir;
		} else {
			vec_sub(temp, my.x);
			vec_set(temp2, temp);
			vec_angle(temp, temp);
			temp.pan = ang(temp.pan - my.pan);  temp.tilt = 0; temp.roll = 0;
			c_rotate(me, temp, ignore_passable);
			//The following 'cap' technique may only be valid for forward relative movement.
			temp.x = min(relMoveSpeed * time, vec_length(temp2));		
			temp.y = 0; temp.z = 0;
			c_move(me, temp, nullvector, ignore_passable);
		}
		wait(1);
	}
}
/************************************
	nodeGetEdges(_ent, _node)
*************************************/
var nodeEdges[10];
var nodeEdgeCount;
var nodeGetEdgesOverflow = 0;
function nodeGetEdges(_ent, _node) {
	nodeGetEdgesOverflow = 0;
	nodeEdgeCount = 0;
	var node0; node0 = 0;
	while(1) {
		node0 = path_nextnode(_ent, _node, nodeEdgeCount + 1);
		if (node0 == 0) { break; }
		if (nodeEdgeCount >= 10) { nodeGetEdgesOverflow = 1; break; }
		nodeEdges[nodeEdgeCount] = node0;
		nodeEdgeCount += 1;
	}
	return nodeEdgeCount;
}

---

Weak, flawed, work-in-progress example of directing an entity from one node to another on a non-linear path using a breadth-first search algorithm:
bfs061109
Instructions:
*[ + ] [ - ] keys (not numpad): zoom camera
*click destination node with mouse; start node is closest node to entity (arrow)
Included:
*the original tutorial (my code is not a copy, but is instead, probably a weaker derivative created from scratch)
*_0b.wdl (an outdated debugging script file)
Applications: none; it's completely useless