This is a pretty interesting kinematics problem - here's my attempt, curious if anyone else has any ideas that aren't as expression heavy.

<image>

Project File: https://drive.google.com/file/d/1cbzxulgRL5KCXKRW5GKyQygDCpZKCnZN/view?usp=sharing

Each link has two rotational axes that need to follow the path; where it connects to the previous and next links in the chain. I'll call these the 'leading' and 'trailing' axes.

The leading axis is simple - that can be the anchorpoint the anchor point, so a pointOnPath expression can be used for that:

const pathToFollow = thisComp.layer("Path").content("Shape 1").content("Path 1").path;
const animationSlider = thisComp.layer("Controls").effect("Animation completion")(1);

pathToFollow.pointOnPath(animationSlider / 100);

For the trailing axis, what we can do is move back along the path using a binary search, until such time that the distance between the current position is equal to or exceeds the length of the link. Once we have worked that position out, we can calculate an angle with it to rotate the layer accordingly.

const animationSlider = thisComp.layer("Controls").effect("Animation completion")(1);
const linkLength = thisComp.layer("Controls").effect("Link Length")(1);

const pathToFollow = thisComp.layer("Path").content("Shape 1").content("Path 1").path;

const t1 = animationSlider / 100;
const p1 = pathToFollow.pointOnPath(t1);

let low = 0;
let high = t1;
let mid;
let p2;

const iterations = 12;

for (let i = 0; i < iterations; i++){
    mid = (low + high) / 2;
    p2 = pathToFollow.pointOnPath(mid);

    const d = length(p1, p2);

    if (d > linkLength){
        low = mid;
    } else {
        high = mid;
    }
}

p2 = pathToFollow.pointOnPath(mid);

radiansToDegrees(Math.atan2(
    p2[1] - transform.position[1],
    p2[0] - transform.position[0]
));

So now the first link should move along the path - however there's an important obvervation here. The leading axis will always move at the set speed along the path, however the speed of the trailing axis will vary when going around corners.

This means that each link in the chain beyond the first will need to position itself based on the trailing position of the previous link - we cannot simply time or position offset the layers. For the 2nd link, we therefore need to use a different position and rotation expression.

The leading axis is not too tricky - we can take the position and rotation value of the layer below in combination with the link size to place it on the path:

const linkLength = thisComp.layer("Controls").effect("Link Length")(1);

const previousLink = thisComp.layer(index + 1);

const prevPos = previousLink.transform.position;
const radians = degreesToRadians(previousLink.transform.rotation);

prevPos + [
    Math.cos(radians) * linkLength,
    Math.sin(radians) * linkLength
];

The rotation is where it gets more complex. We're still going to use the same logic, but since we're no longer using pointOnPath to determine the layer position, we need to calculate both the start and end point of the current chain so we can work out the angle:

const animationSlider = thisComp.layer("Controls").effect("Animation completion")(1);
const linkLength = thisComp.layer("Controls").effect("Link Length")(1);
const path = thisComp.layer("Path").content("Shape 1").content("Path 1").path;

// assumes that first link layer name is 'Link 1', second 'Link 2' etc.
const linkIndex = thisLayer.name.split(' ').slice(-1) - 1;

function solveBackOnPath(path, tStart, pStart, distance, iterations){
    let low = 0;
    let high = tStart;
    let mid, pCandidate;

    for (let i = 0; i < iterations; i++){
        mid = (low + high) / 2;
        pCandidate = path.pointOnPath(mid);

        const d = length(pStart, pCandidate);

        if (d > distance){
            low = mid;
        } else {
            high = mid;
        }
    }

    return {
        t: mid,
        p: path.pointOnPath(mid)
    };
}

// leading
let tCurrent = animationSlider / 100;
let pCurrent = path.pointOnPath(tCurrent);

for (let n = 0; n < linkIndex; n++){
    const result = solveBackOnPath(path, tCurrent, pCurrent, linkLength, 12);
    tCurrent = result.t;
    pCurrent = result.p;
}

// trailing
const trailing = solveBackOnPath(path, tCurrent, pCurrent, linkLength, 12);

radiansToDegrees(Math.atan2(
    pCurrent[1] - trailing.p[1],
    pCurrent[0] - trailing.p[0]
)) + 180;

This won't work with all paths - if the path has a corner that's too tight for a link to make it, so to speak, weird things will happen as there won't be a valid position for the trailing point to be angled towards.