Note-- and laugh at-- kludgey fix for the first arm being broken. Does it have to do with the 0-value in the array having no "i-1" value to compare to?

If you mean in this bit of code:

for(int i=x.length-1; i>=1; i--) {
      positionSegment(i, i-1); 
 } 

...then no not quite:  If there were no value to compare to you'd get an array outOfBounds error...  No I think the problem is more likely to do with the fact you're using the same arrays (x[], y[] and angle[]) for the segment variables on all the arms and at some point the variables from one are cross-contaminating another.

TBH the 'working' code I posted could have been cleaned up a lot more.  Strictly speaking when using an array-based approach in this situation - where some of the repeated item's variables are themselves already arrays - you'd normally start using 2D arrays; but then things starts getting unnecessarily convoluted.

The Class-based approach is actually far simpler (though don't even try figuring out a segment sub-class; I'd forgotten the recursive horrors of IK and quickly gave up.  Perhaps a challenge for when I have a clearer head.)

Here's an Arm class - most of the code is taken from the Reach example and it's just been built into a class:

1. class Arm {
2.   // - - - properties - - - //
3.   int numSegments;
4.   float segLength;
5.  
6.   float[] x;
7.   float[] y;
8.   float[] angle;
9.  
10.   float targetX, targetY;
11.   float reachToX, reachToY;
12.   // colour with default value
13.   color colour = color(255, 25);
14.  
15.   // - - - constructor - - - //
16.   Arm(int numSegments, float segLength, float baseX, float baseY) {
17.    
18.     this.numSegments = numSegments;
19.     this.segLength = segLength;
20.    
21.     x = new float[numSegments];
22.     y = new float[numSegments];
23.     angle = new float[numSegments];
24.    
25.     x[x.length-1] = baseX;     // Set base x-coordinate
26.     y[x.length-1] = baseY;  // Set base y-coordinate
27.    
28.   }
29.  
30.   // - - - overloaded constructor
31.   Arm(int numSegments, float segLength, float baseX, float baseY, color colour) {
32.     // calls the first constructor with base arguments: saves re-writing code :)
33.     this(numSegments, segLength, baseX, baseY);
34.     this.colour = colour;   
35.   }
36.  
37.   // - - - methods - - - //
38.   void draw() {
39.    
40.     reachSegment(0, reachToX, reachToY);
41.    
42.     for(int i=1; i<numSegments; i++) {
43.       reachSegment(i, targetX, targetY);
44.     }
45.    
46.     for(int i=x.length-1; i>=1; i--) {
47.       positionSegment(i, i-1); 
48.     }
49.     for(int i=0; i<x.length; i++) {
50.       segment(x[i], y[i], angle[i], (i+1)*2);
51.     }
52.   }
53.  
54.   void positionSegment(int a, int b) {
55.     x[b] = x[a] + cos(angle[a]) * segLength;
56.     y[b] = y[a] + sin(angle[a]) * segLength;
57.   }
58.  
59.   void reachSegment(int i, float xin, float yin) {
60.     float dx = xin - x[i];
61.     float dy = yin - y[i];
62.     angle[i] = atan2(dy, dx); 
63.     targetX = xin - cos(angle[i]) * segLength;
64.     targetY = yin - sin(angle[i]) * segLength;
65.   }
66.  
67.   void segment(float x, float y, float a, float sw) {
68.     stroke(colour);
69.     strokeWeight(sw);
70.     pushMatrix();
71.     translate(x, y);
72.     rotate(a);
73.     line(0, 0, segLength, 0);
74.     popMatrix();
75.   }
76.  
77.   // this method was added to simplify passing a point to reach towards
78.   void updateTarget(float reachToX, float reachToY){
79.     this.reachToX = reachToX;
80.     this.reachToY = reachToY;
81.   }
82.  
83. }

And here's some code to create and draw some arms:

1. ArrayList arms;
2. int rows = 8;
3. int columns = 10;
4. 
   
5. void setup() {
6.   size(600,400);
7.   smooth();
8.   // create an empty ArrayList
9.   arms = new ArrayList();
10.  
11.   float xOffset = width/columns;
12.   float yOffset = height/rows;
13.  
14.  
15.   for(int i=0; i< rows; i++) {
16.     for(int j=0; j< columns; j++){
17.       // caculate arm coordinates (separated for clarity)
18.       float xPosition = xOffset * 0.25 + j * xOffset;
19.       // modulo is useful here to offset each alternating row:
20.       if(i % 2 == 0){
21.         xPosition = xOffset * 0.75 + j * xOffset;
22.       }
23.       float yPosition = yOffset/2 + i * yOffset;
24.       // create a new arm (separated out for clarity)
    
25.       Arm arm = new Arm(10, 20, xPosition, yPosition, color(50,200,50,20));
26.       // add to the ArrayList
27.       arms.add(arm);
28.     }
29.    
30.   }
31. }
32. 
    
33. void draw() {
34.   background(0);
35.  
36.   // set targets:
37.   for(int i=0; i< arms.size(); i++) {
38.     Arm arm = (Arm) arms.get(i);
39.     arm.updateTarget(mouseX, mouseY);
40.     arm.draw();
41.   }
42. }

Now the array properties are safely tucked away in the class there's no need to rely on convoluted multi-dimensional arrays: all you're interested in is positioning the arm and letting it do its stuff.  I'm using an ArrayList to store the Arm objects.  There's some syntax to get used to with them but they offer some advantages when working with objects (e.g. much easier to work with an unknown number of objects as you don't have to declare a dimension when you create one).

Jumping in at the deep end is one way to learn (and seems to suit some people!); but if you get stumped it's definitely worth trying to separate the problem out into a simpler sketch and then build the solution back into your main project.  Another good way to learn is to try and solve people's problems on the forums  :)