In Cycles, I'd like to create a misty torus. Create torus, Volume Scatter note into the Volume Material Output node. Done.
But I'd like to be able to adjust the density of the scatter with respect to surface proximity. So the closer the scatter effect gets to the surface of the object, the more transparent or "less dense' it becomes.
Any suggestions? I'd like this to be material-specific. I could do this in the compositor, but blurring introduces other problems.
An alternative solution to the 'pure' mathematical solution (https://blender.stackexchange.com/a/70340/29586) is to use the Point Density texture node to convert a circular mesh into a density as follows (using a mesh created from a BezierCircle) :
The Multiply and Power nodes can again be used to manipulate the scale and fuzziness of the generated torus.
This has the added advantage that you can manipulate the source mesh as desired :
Note, this method may be less efficient than the pure mathematical approach described in the previous answer due to the use of the Point Density node. It will also be dependent on the number of vertices in the source mesh and the resolution of the Point Density (lower values will produce less accurate results). However, it is more versatile since the source mesh can be easily manipulated.
Blend file attached. 
There seems to be an error in my calculations. I think I will manage to review them later.
As Ibalazscs pointed out, you can control volume with the existing math nodes and procedural textures.
I will setup a mathematic procedural torus to use as density. This will not be affected by the geometry, sadly, but will work as a substitute solution.
To control the density of a volume, we can connect a texture or other value node to the density input of the Volume Scatter Node.
Starting with a two dimensional equation, let's control the volume of a cylinder with a colorramp or RGBcurve.
Here is the relatively simple mathematical basis. We need the equation of a circle.
x**2 + y**2 = radius**2
radius = (x**2 + y**2)**0.5
This will result in values from 0 to 1, starting from the center of the XY circle to any point on the circle.
Translated into a node setup, we have to use the Converter>Math nodes.
Connect the last node to a colorramp and we can see the effect on a 3D object in material or rendered mode.
The complete node setup looks like this.
I use a multiply node before the RGB curves to "scale" the circle. The RGB curves modify the density from the center of the circle to the rim. I have set them to the various examples in the beginning. The multiply node after the RGB curves raise the upper density limit. Close to zero (transparent) values will stay relatively unaffected, values close to 1 or higher will become more dense.
The position attribute of the Geometry node holds the XYZ coordinates. The separate RGB node extracts the three channels.
Important: The position attribute is in world coordinates. Use the Object Info > Location attribute if you move your object.
We want to control the density using values from 0 to 1 ranging from the major radius to the (major + minor) radius.
The value of the major radius in XY is currently 0.
-1), now we have values from 0 to -infinity. Add a value with an add node. The second input of the add node is the minor radius. Clamp this value. We now have a range of 0 to 1 from the outer rim of the torus to the inner circle.
Make sure your domain object is large enough.
If you want to add a shader to the outer surface, add a torus with correspoing major and minor radius. In my case
Varying the density based on the proximity to the surface of the mesh is tricky - and requires use of complicated OSL shaders to probe out the nearby surface of the mesh. A much simpler method is to generate the torus mathematically as a procedural volumetric material. This means that we can more easily vary how the density of the torus varies as it moves away from the center.
Firstly, we need to create a volumetric material that varies based on distance. This can be achieved with the following material :
This takes the 'object' coordinates and feeds this into both sockets of a Dot Product vector math node. The Dot Product returns a scalar value based on the magnitudes and relative directions of the input vectors. By using the same vector for both inputs the node returns a value based purely on the distance of the vector (actually distance squared) - this returns a value base on the distance from (0,0,0) - ie, the distance from the center of the mesh. This is passed through a Multiply node to allow the final result to be scaled, subtracted from 1 (clamped) so the result varies from 1 at the center to 0 at its edge, passed through a Power node to allow the falloff to be varied (to make it either more sharp or more fuzzy) and, finally, a Mulltiply node to allow it to be made overall more or less dense. This is then used as the Density of both a Scatter and an Absorption shader node - which are then combined for the final material output.
By creating a mesh (eg, a cube) to act as a 'domain' for the material and varying the Multiply and Power nodes, this can produce an effect similar to the following :
Small 'Power' (eg, 0.1) will produce a very sharp edge to the sphere while large values (eg, 10) will produce a more fuzzy edge. Reducing the first Multiply will increase the sphere's size while increasing it reduces its size.
To turn this into a Torus, we simply need to add some nodes to position the reference point (in the above case, this was the Origin) at various points along a circle - in particular, at the closest point along the circular path. The size of the circle will then dictate the size of the torus and the above Multiply and Power nodes will determine its fuzziness and thickness.
This can be achieved as shown below :
The center of the circle is at the Origin (0,0,0). The orientation of the circle is determined by a Normal vector - in the same way as for the Normal of a surface. Varying the Normal will change the orientation of the torus. The radius of the circle is controlled via an input Value (Radius).
The Cross Product vector math node is used to determine the direction of the closest point of the circle. The Cross Product always returns a vector which is perpendicular to both of the input vectors. By passing in the Normal to the first Cross Product, this will produce a vector that is along the plane of the circle - but at 90 degrees to the direction of the point being sampled. The second Cross Product takes that vector and produces one at -90 degrees to that - this will be along the plane of the circle and in the direction of the point being sampled (which will be the point on the circle that is closest to the point being sampled). This vector is Normalized (so it's magnitude is '1') and then multiplied by the desired Radius. The result of this can then be used to find the actual reference point on the circle that can be measured against the sample point to determine how close that point is to the circle.
We then have the Multiply and Power nodes used to control the falloff of the edge of the torus as in the previous example (but fed from Value nodes and given appropriate names).
This can then produce the following result :
Blend file attached. 
An absorption volume shader is automatically darker around the thicker areas, maybe all you need is to use it instead of scatter, like here: Volumetric gradient based on density?
To be physically correct, you need both of them, mixed with an Add Shader. If you really want to control the scatter density, then continue reading...
If a (slightly random) cloud-like appearance is OK, then see this question: Is there an easy way to make volumetric clouds for Cycles? (you would start with a torus instead of a cube)
If you need precision, you can start with this one: Controlling volume density
Here (in the second example) the density is based on the X location. Now for a torus, the math becomes somewhat more complicated: the density depends on the distance from the center, and on the Z location. I trust you that you can figure out the details :)
EDIT Just for fun, here are three torus-clouds (of type stratus, cirrus and cumulous) created with the cloud generator addon:
The cloud generator uses a particle system internally to set up the point density, so theoretically its source code could be modified so that the points are less randomly positioned.
