I'm thinking it may be helpful to restate the actual problem, if only just for yourself. Some things that may be helpful:

o You wrote you tested with mechanicarm.RotateAround(mechanicarm.position, Vector3.up,-0.5f);. The thing is, that always give a perfect spin on the horizontal plane, even if you randomly roll 0-360 for your starting spins (it says to spin around the global UP line, coming straight up from your center.) Since it always works, it isn't a useful test.

o Debug.DrawRay(mechanicalarm.position, xxxx ); assumes that xxxx is in World coords, so it can't be used to test if local coords are correct. If the question is "points straight up" then the answer is Debug.DrawRay(..., Vector3.up);

o Almost nothing takes local coords as input. Are you sure you need them? RotateAround takes the axis in World; DrawRay takes the dir as World; transform.Rotate(x,y,z); does a local rotate, but it auto-computes your local x/y/z axis for you. If you are sure you need local, try testing with myChild.localPosition = someDir*4; (for example, if someDir is Vector3.up, that puts the child 4 out on your current (local) up direction.)

Are you sure you don't just want mechArm.up? That gives you the local UP in World coords. It's so short since lots of people use it. Debug.DrawRay(mechArm.position, mechArm.up*4); makes a ray always pointing to your current up. It rotates with the model, but is frozen with respect to the model.

This seems to be it (world up in local coords):

Vector3 worldUpInLocal = Quaternion.Inverse(transform.rotation) * Vector3.up;

My test code, with comments on the logic behind it. I think a better way (for me) would have been to note that transform.up is shorthand for transform.rotation*Vector3.up; and to try to solve that.

Keeping the locals and worlds straight is a real stumper. For example, the description of transform.InverseTransformDirection(Vector3.up) says it should work. But, it usually (not always) gives the same numbers as my answer, but with signs flipped or x/z flipped.

// testing rotation math code:
Transform kid; // attempt to use result to place him world up from me
public Vector3 U; // result
public Vector3 U2; // transform.up, to compare.
// turns out result bears NO obvious relation to transform.up

void Update () {
  // cheesy way to get lots of random spins:
  if(Input.GetKey("z")) {
float yRot = Random.value*360;   
float xRot = Random.value*360;   
float zRot = Random.value*360;
transform.rotation = Quaternion.Euler(xRot, yRot, zRot);
    // show in Inspector, to compare:
U2 = transform.up;
  }
  // The math:
  // transform.rotation  is from no spin to our spin;
  // This computes other way, from our spin back to normal:
  Quaternion qq = Quaternion.Inverse(transform.rotation);
  // Apply that to "local up in local coords" to get "world up in local coords":
  U = qq * Vector3.up;

  // Check:
  // U.xyz in local coords means, to move distance U.x along local x-axis, etc...
  // Should take us to the local (x,y,z) which is also world up:
  kid.position = transform.position +
    (U.x * transform.right + U.y * transform.up + U.z * transform.forward) * 4;
  // NOTE: *4 is just to make it easier to spot
}