I have no idea about OpenGL ES, but in standard OpenGL you would set the opacity by declaring a colour for the texture before you use it:
// R, G, B, A
glColor4f(1.0, 1.0, 1.0, 0.5);
The example would give you 50% alpha without affecting the colour of your texture. By adjusting the other values you can shift the texture colour too.
Given that textures A and B are RGB images, then perhaps you can make one of them into an RGBA image, and render the mask in the alpha channel of one image. This gets you within the iPhone's limit of two texture units, allowing you to do this in one pass, without blending.
GLSL pseudocode:
vec4 a = texture2D(textureA, texcoord);
vec4 b = texture2D(textureB, texcoord);
gl_FragColor = vec4(a.rgb * a.a + b.rgb * (1-a.a), dont_care.a);
Texture Environment for Unit 0: (samples RGB image B, and passes it on to the next stage)
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
Texture Environment for Unit 1: (image B are available in Cp and 'Ap' source. A is available in 'Cs'. Mask is available in 'As'. see Table 3.15 in the GL spec).
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textureA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
Read section 3.7.12 Texture Environments and Texture Functions in the OpenGL ES 1.1 spec for full information.
To actually render your scene into the alpha channel of the image, it may be helpful to use glColorMask(), to allow writing to only the alpha channel. How you actually get the data into that channel really depends on exactly what you're drawing to generate that mask.
Best Answer
No. In general, graphics chips really don't like palletized textures (why? because reading any texel from it requires two memory reads, one of the index and another into the palette. Double the latency of a normal read).
If you're only after saving memory, then look into compressed texture formats. In iPhone specifically, it supports PVRTC compressed formats with 2 bits/pixel and 4 bits/pixel. The compression is lossy (just like palette compression is often lossy), but memory and bandwidth savings are substantial.