I think your "super fast" problem is occuring because you're not resetting the startTime variable when you increment the targetwaypoint counter. This means that for every transition after the first one, the duration has already elapsed.

As for the 'index out of range' error, I would guess that's occuring because you're assigning the new endPoint before you check whether the targetwaypoint variable should be wrapped back to zero.

Move the line:

endPoint = waypoints[targetwaypoint].position;

...to after the check where you test if it's the last item in the array. (remember, array access is zero-indexed, so if targetwaypoint == waypoints.Length, then targetwaypoint isn't a valid index!

(If your array is 8 items long, the first item is at position zero, and the last item is at position 7!)

Also, you might be interested in a neat way of "wrapping" your integer index counter using the modulus operator.

Also, I've moved the Lerp interpolation value to a separate variable for shorter line length, and fixed the indentation :)

So, with these fixes, your could might look like this.

// array to hold waypoint locations
var waypoints : Transform[];

// variable to control time taken to travel between points
var duration : float = 1.0;

private var startPoint : Vector3;
private var endPoint : Vector3;
private var startTime : float;

// the array index number of the current target waypoint
private var targetwaypoint : int;

function Start() {

    startPoint = transform.position;
    startTime = Time.time;

    if(waypoints.Length <= 0){
        Debug.Log("No waypoints found");
        enabled = false;
    }

    targetwaypoint = 0;
    endPoint = waypoints[targetwaypoint].position;
}

function Update () {

    var i = (Time.time - startTime) / duration;
    transform.position = Vector3.Lerp(startPoint, endPoint, i);

    if(i >= 1){

        startTime = Time.time;

        // increment and wrap the target waypoint index
        targetwaypoint++;
        targetwaypoint = targetwaypoint % waypoints.Length;

        // assign the new lerp waypoints
        startPoint = endPoint;
        endPoint = waypoints[targetwaypoint].position;

    }
}

I've been looking into stepping back through the array when I reach the end. I didn't achieve that yet (seemed to have become a bit distracted in the process!) but I've modified my code quite a bit so thought I would post it here as an alternate solution.

Now i'm using a normal Javascript array rather than an in-built one (although i've read in-built ones are faster). This approach allows me to use the Shift and Add functions to achieve the same effect as Duck's modulus approach (as far as I can tell) and also means that the array is resizeable. Since Javascript arrays can't be modified from the editor i've added some script to automatically add the waypoints to the array at initialisation (much more efficient than dragging them into the editor).

Currently I have an empty object called waypoints with child cubes for the individual waypoints. The script is attached to the NPC and so has to find the waypoint object's children (took me a while to get that working!). I'd be happy to hear and comments/criticism, and thanks once again to you Duck for your help.

// array to hold waypoint locations
var waypoints = new Array();

// variable to control time taken to travel between points
var duration : float = 1.0;

private var startPoint : Vector3;
private var endPoint : Vector3;
private var startTime : float;

private var wp : Transform;

// the array index number of the current target waypoint
private var targetwaypoint : int;

function Start() {
    startPoint = transform.position;
    startTime = Time.time;

    // store a reference to the transform of the waypoints object
    wp = GameObject.Find("waypoints").transform;

    // for each of the child objects of the waypoints object
    for (var child : Transform in wp) {

        // add them to the waypoints array
        waypoints.Push(child);
    }   


    if(waypoints.length <= 0){
        Debug.Log("No waypoints found");
        enabled = false;
    }

    targetwaypoint = 0;

    // set the initial end point to the first item in the array
    endPoint = waypoints[targetwaypoint].position;
    }

function Update () {

    var i = (Time.time - startTime) / duration;
    transform.position = Vector3.Lerp(startPoint, endPoint, i);

    // if we have reached the target
    if(i >= 1){

        // store the current time as the new start time
        startTime = Time.time;

        // store the value of the current item in the array and remove it from the array
        currentwaypoint = waypoints.Shift();
        // add the previously removed item to the end of the array
        waypoints.Add(currentwaypoint);


        // set our start point to our current position
        startPoint = endPoint;


        //set our new endpoint to the position of the new target waypoint
        endPoint = waypoints[targetwaypoint].position;

    }


}