Unfortunately it's not possible to do this just with a projection matrix since it only can do linear projection. What you want requires z². It is possible to do this with a custom shader, but your geometry need to have "enough" vertices along the "bend". See this example in Minecraft. I think you can't do the bending in the fragment shader since it requires you to offset the geometry depending on the distance to the camera. AFAIK this can only be done in the vertex shader.

edit
I'm far from being a shader expert, so it take a while until it worked (i hate syntax errors and totally useless errors :D). I've written a very simple shader that can bend the objects that are drawn with it. However it has one downside: Every object needs a custom shader or it won't fit together with the other things.

This example scene has 3 objects in a row (two planes and one cube). The camera is sliding linearly on the z-axis over the objects. The first plane has my curved shader, the second plane has a normal diffuse shader and the cube also has my curved shader.

Webplayer

I've packed the sample together in a package.

Here's the important part of the vertex shader:

v2f vert (appdata_base v)
{
    v2f o;
    // The vertex position in view-space (camera space)
    float4 vPos = mul (UNITY_MATRIX_MV, v.vertex);

    // Get distance from camera and scale it down with the global _Dist parameter
    float zOff = vPos.z/_Dist;
    // Add the offset with a quadratic curve to the vertex position
    vPos += _QOffset*zOff*zOff;

    o.pos = mul (UNITY_MATRIX_P, vPos);
    o.uv = v.texcoord;
    return o;
}

_Dist wouldn't be necessary. It just scales the whole vector, but it helps to find nice values ;)

As you can see the first plane bends quite nicely because the default Unity plane consists of 10x10 quads, so there are many vertices along the bending edge.

The cube doesn't have subdivs. The vertices bend correctly, but the edges will stay linear.

The second plane keep the original position since it doesn't have a bending shader.

Keep in mind that the actual objects will be on a straight line. This is very useful for physics and collisions. Only the view is bent.
Note that the visibillity check that is performed by Unity does not take the bending into account. So an object could be bend outside of the viewport, but it is still rendered because the actual position is still in view. Also the other way round. If an object would be bend into the viewport, but the actual object is outside of the viewing frustum, the object will not be drawn at all.