I had the idea to pre-calculate the distortion of each segment while configuring the path. It seems to work ok.

First I created a class to hold the distortion of each segment

class SplineSegment
{
    public float StartPercentage;
    public float EndPercentage;
    public float Length;
    public float Distortion;
}

Then I calculated all of the values and placed them in a queue

var pathLength = iTween.PathLength(array);
var normalisedSegmentLength = pathLength / (array.Length - 1);

pathSegments = new Queue<SplineSegment>();

for (int i = 0; i < (array.Length-1); i++)
{
    var float_i = (float)i;
    var segmentLength = iTween.PathLength(new Vector3[] { array[i], array[i + 1] });
    pathSegments.Enqueue(new SplineSegment()
    {
        Length = segmentLength,
        StartPercentage = (float_i / (array.Length - 1)),
        EndPercentage = ((float_i + 1) / (array.Length - 1)),
        Distortion = normalisedSegmentLength / segmentLength
    });
}

Finally, I update the position in the fixed update

void FixedUpdate()
{
    if (progress > pathSegments.Peek().EndPercentage) pathSegments.Dequeue();
    progress += Time.deltaTime * speed * pathSegments.Peek().Distortion;
    iTween.PutOnPath(gameObject, path, progress);
}

A bit of extra work, appears functional

Well, I figured it out!

You need to get the object's current percentage position on the path (point on path). look ahead a little bit on that path, adding .01(1%) should be enough looking ahead. Get the distance between the obj's position and the point ahead. Get the full length of that path, and take 1% of that path's distance. Dividing the real distance by the distance you got from looking ahead will get you the amount the path is distorted at that point.

From there, just multiply the percentage of how much you should move that frame by the distortion, and that should give you the change in distorted percentage. Add that to your current position and to feed into PointOnPath or PutOnPath.

Unfortunately I don't think there's a way to do with with MoveTo or some of the others.

Ah, I figured I couldn't have been the only one having the problem, but the lack of responses made me think otherwise. Still wrote up a quick solution in case, sorry for the lack of detail and code. I actually put the solution together in uScript, so the code it generated for it probably isn't best for learning how to do this. But maybe I can help you and we can provide the community with a good sample.

What part of my description is tripping you up? It's okay to say the beginning, I just want to know where to start working from. There's also the possibility I left something out since I wrote it up quick.

Sorry for the delay here, I'm pretty busy.

You're right, you should know the percentage of where your object is on the path. From that point you need to look ahead in the direction you are moving. So you should add or subtract (depending on direction) .01 to that number. We get the position of out object, and then the position of this look ahead point, and we measure the distance between these two points. We do this by putting the coordinates for both points into PathLength.

Please note, at this point you're not measuring along the line but creating a new line. Because of this slight errors can occur. I've had good success with what I'm doing, but if for some reason you need super accurate results, you might want to make sure this is the method for you before you use it. It's a very small issue, and I don't think many would need more accuracy, but here is a description of why it can cause errors. Imagine your 1% length of the path is on a section shaped like a 'U'. You would be drawing a line across the top of the U instead of around it. Therefore for this one frame the calculation would be slightly off. I don't know what you use Unity for (or what others using might be using it for) but for games I'd say this is probably good enough. If you're using unity and iTween for some scientific research or something, you'll have to decide if this is accurate enough for you. TL/DR: fine for games, maybe not for science.

Now we have the distance between these points, however, iTween distorts this 1%, so this distance isn't really 1% of the path like it thinks. Thankfully, by using PathLength() we can get the distance of the whole path. It does all the magical math to figure out the distance of the path even if there are curves in it. So once we have the real length of the path, we need to compare 1% of the real length to the 1% of the iTween length.

So we take the real 1% distance and divide it by the iTween 1% distance. This will give us the amount that the iTween 1% distance is distorted.

You should convert your velocity into percentage the object moves on the path each frame. I'll assume you don't need this described. Take this movement percentage and multiply it by the distortion. This gives you the percentage amount you need to move by to compensate for the distortion. Add (or subtract, depending on direction) it to your object's position percentage on the path.

so, maybe I'm making this easier then it's supposed to be but I've worked around this problem with iTween by using MoveTo (Next Point in Path), the distance to the next point used to alter the speed and the onComplete parameter to start the tween again for the point after the next point... easier to code then to say...

var path : Vector3[];
var nextPoint : int = 0;
var speed : float = 10.0;

function Start () {
    Tween();
}

function Tween () {
    var toPoint :  Vector3 = path[nextPoint];
    var distance : float = Vector3.Distance(toPoint, transform.position);
    iTween.MoveTo(gameObject,{"position":toPoint,"time":distance/speed,"easetype":"linear","oncomplete":"Complete"});
}

function Complete () {
    nextPoint++;
    if (nextPoint < path.Length) Tween();
}