1. When you use lerp with the same variable as input and output, this will produce undesired results.
2. When you use lerp you need to change the interpolation value to move from one to the other.
3. If you want particles to follow a path, make them follow a path, not each other.

When you do the latter, the code becomes more flexible. There can be a difference between the number of particles and the number of path points. Particles can have different speeds.

Adapted Code

1. import processing.opengl.*;
2. import geomerative.*;
3.  
4. ArrayList <PVector> path = new ArrayList <PVector> ();
5. ArrayList <Particle> particles = new ArrayList <Particle> ();
6.  
7. void setup() {
8.   size(600, 400, OPENGL);
9.   smooth();
10.  
11.   RG.init(this);
12.   RCommand.setSegmentLength(10);
13.   RFont font = new RFont("lucon.ttf", 200, RFont.CENTER);
14.   RPoint[] points = font.toGroup("GEO").getPoints();
15.  
16.   int xoff = width/2;
17.   int yoff = 2*height/3;
18.  
19.   for (int i=0; i<points.length; i++) {
20.     path.add( new PVector(xoff + points[i].x, yoff + points[i].y) );
21.     particles.add( new Particle(xoff + points[i].x, yoff + points[i].y, 3, i) );
22.   }
23. }
24.  
25. void draw() {
26.   background(0);
27.   for (Particle p : particles) {
28.     p.update();
29.     p.display();
30.   }
31. }
32.  
33. class Particle {
34.   PVector pos;
35.   float x, y, d, interpolate = 1;
36.   float speed = 0.05;
37.   int target;
38.  
39.   Particle(float x, float y, float d, int target) {
40.     pos = new PVector (x, y);
41.     this.d = d;
42.     this.target = target;
43.   }
44.  
45.   void update() {
46.     interpolate += speed;
47.     if (interpolate >= 1) {
48.       pos = path.get(target).get();
49.       target = (target+1)%path.size();
50.       interpolate = 0;
51.     }
52.     PVector t = path.get(target);
53.     x = lerp(pos.x, t.x, interpolate);
54.     y = lerp(pos.y, t.y, interpolate);
55.   }
56.  
57.   void display() {
58.     noStroke();
59.     fill(255, 125);
60.     ellipse(x, y, d, d);
61.   }
62. }

1. import processing.opengl.*;
2. import geomerative.*;
3.  
4. ArrayList <PVector> path = new ArrayList <PVector> ();
5. ArrayList <Particle> particles = new ArrayList <Particle> ();
6.  
7. void setup() {
8.   size(600, 400, OPENGL);
9.   colorMode(HSB, 360, 100, 100);
10.   noStroke();
11.   smooth();
12.  
13.   RG.init(this);
14.   RCommand.setSegmentLength(10);
15.   RFont font = new RFont("lucon.ttf", 200, RFont.CENTER);
16.   RPoint[] points = font.toGroup("GEO").getPoints();
17.  
18.   for (int i=0; i<points.length; i++) { path.add( new PVector(points[i].x, points[i].y) ); }
19.   for (int i=0; i<1000; i++) { particles.add( new Particle() ); }
20. }
21.  
22. void draw() {
23.   background(0);
24.   translate(width/2, 2*height/3);
25.   for (Particle p : particles) {
26.     p.update();
27.     p.display();
28.   }
29. }
30.  
31. class Particle {
32.   PVector pos;
33.   float speed, px, py, x, y, d, interpolate = 1;
34.   int target;
35.  
36.   Particle() {
37.     pos = new PVector();
38.     d = random(1, 10);
39.     target = int(random(path.size()));
40.     speed = random(0.001, 0.25);
41.   }
42.  
43.   void update() {
44.     interpolate += speed;
45.     if (interpolate >= 1) {
46.       pos = path.get(target).get();
47.       target = (target+1)%path.size();
48.       interpolate = 0;
49.     }
50.     PVector t = path.get(target);
51.     x = lerp(pos.x, t.x, interpolate);
52.     y = lerp(pos.y, t.y, interpolate);
53.   }
54.  
55.   void display() {
56.     if (dist(x,y, px,py)<2.5) {
57.       fill((frameCount-target)%360, 100, 100);
58.       float difx = sin((y + frameCount)*0.01)*20;
59.       float dify = cos((x + frameCount)*0.03)*25;
60.       ellipse(x+difx, y+dify, d, d);
61.     }
62.     px = x;
63.     py = y;   
64.   }
65. }