Is there a version of Camera.WorldtoScreenPoint for equirect projections?

No, there is no built-in conversion since the cubemap is a 360° projection and not directly related to the camera view or the camera projection. However since the result is an equirect projection of the whole 360°, just using plain lat / lon conversion should work just fine considering the camera position as center.

I have never used the "RenderToCubemap()" or "ConvertToEquirect()" methods, so I don't know if the rendered image is actually relative to the camera rotation or relative to worldspace. Though the only difference would be that you first need to convert between local and world space coordinates.

To convert from worldspace to the equirect projection, just determine the longitude / azimuth (rotation angle around the y-axis) as well as the latitude / polar angle with respect to the camera position.

For localspace conversion, you can just use:

 Vector3 v = Camera.transform.InverseTransformPoint(worldSpacePoint);

For worldspace conversion just subtract the camera position

 Vector3 v = worldSpacePoint - Camera.transform.position;

With that vector we can determine the azimuth using Mathf.Atan2

 float azimuth = Mathf.Atan2(v.z, v.x);

The polar angle can be determined from the normalized vector's y component

 Vector3 dir = v.normalized;
 float polar = Mathf.ASin(dir.y);

Next you want to make sure the angles are positive:

 azimuth += Mathf.PI*2; // 360°
 polar += Mathf.PI; // 180°

Next divide by the angle range to get a value between 0 and 1:

 float U = azimuth / Mathf.PI*2;
 float V = polar / Mathf.PI;

Those are essentially your UV coordinate of your equirect image. The z coordinate (distance from the camera) is simply the magnitude of the v-vector.

Note that as I said there might be some offsets involved or some signs need to be flipped but the general idea is the same.

To calculate the reverse you just do it in reverse. So the UV ranges have to be converted into angles (+-2PI for U and +-PI for V). With those we can simply construct a direction vector using Mathf.Sin and Mathf.Cos. Once we have the normalized vector we can multiply the direction by the wanted distance from the camera to get an actual point. In the last step again either add it to the camera position or use TransformPoint.