Well, using pattern matching you can do it quite easily. You just define two distance function of different arities (e.g., the number of arguments). You call the first distance function and it calls the second one. This is a form of tail recursion. In each step the first element of the list is removed and the distance to the next point is computed and stored in the second argument (which is called an accumulator) and the function is called again. In the last step only one coordinate remains and then the final distance is computed and returned (with no recursion).

Clear[distance, x1, x2, y1, y2];
distance[pts_List] := distance[pts, 0];
distance[{{x1_, y1_}, {x2_, y2_}, rest___}, tot_] := 
  distance[{{x2, y2}, rest}, Abs[x1 - x2] + Abs[y1 - y2]];
distance[{{x_, y_}}, len_] := len + Abs[x] + Abs[y];

Now, notice that your definition of a distance is the ManhattanDistance that is already defined in Mathematica, so I change the program to use it

Clear[distance, x1, x2, y1, y2];
distance[pts_List] := distance[pts, 0];
distance[{{x1_, y1_}, {x2_, y2_}, rest___}, tot_] := 
  distance[{{x2, y2}, rest}, ManhattanDistance[{x1, y1}, {x2, y2}]];
distance[{{x_, y_}}, len_] := len + ManhattanDistance[{x, y}, {0, 0}];

As a last step, if you want to compute also the distance from the origin to the first point (coordinate) then all you need is to change the initial distance as follows

Clear[distance, x1, x2, y1, y2];
distance[pts_List] := 
  distance[pts, ManhattanDistance[First[pts], {0, 0}]];
distance[{{x1_, y1_}, {x2_, y2_}, rest___}, tot_] := 
  distance[{{x2, y2}, rest}, ManhattanDistance[{x1, y1}, {x2, y2}]];
distance[{{x_, y_}}, len_] := len + ManhattanDistance[{x, y}, {0, 0}];

yehuda

This does not implement the distance from the origin {0,0} as the OP asked for... You need {0,0} and {0,0} at the beginning and the end of the list before partitioning it. So, use

Partition[{pts__List},2,1,{-1,1},{{0,0}}]

yehuda

One comment though,

A recursive solution is "not so nice" only because Mathematica is not a true functional language (in spite of the fact that it supports functional programming style). In functional languages (e.g., Erlang, Clojure, F# etc.) recursion is the only way to implement iterations (well, almost the only way, there is list comprehension) . This is especially true if that language supports pattern matching (e.g., Erlang, but certainly far from the level of Mathematica) and tail recursion optimization. However, in Mathematica this is not the case. I have tackled many cases were the adoption of tail recursion is unsuccessful or very inefficient, and Sander'c comments are certainly right for large problems.

yehuda