The relevant code is as follows: 

#declare radius=2 
#declare piunit=(2*pi)/6 //sets number of objects per 360 degrees 
#declare phase_offset = piunit/2 //offsets phase 
#declare Count= (-pi) 
#while (Count < pi) 

#declare x=sin(Count+phase_offset)*radius 
#declare y=cos(Count+phase_offset)*radius 

#declare dish= 
 cylinder { < 0, -1, 0>, < 0, 1, 0>, 1 
 scale  < 3, 0.25, 3 > 
 rotate  < 90, 0, 0 > 
 } 

#declare dishcutout= 
 cylinder { < 0, -1, 0>, < 0, 1, 0>, 1.3 
 scale  < 0.5, 0.5, 0.5 > 
 rotate  < 90, 0, 0 > 
 translate  < x,  y, 0 > 
 } 

/* 
 cylinder { < 0, -1, 0>, < 0, 1, 0>, 1.3 
 scale  < 0.5, 0.5, 0.5 > 
 rotate  < 90, 0, 0 > 
 translate  < x,  y, 0 > 
 pigment { Black } 
 } 
*/ 

difference 
{ 
  object {dish} 
  object {dishcutout} 
  texture { Brushed_Aluminum } 
} 

#declare Count=Count+piunit 
#end 

When I run the loop, I only get one cutout in the 6 o'clock position from the base object. 

If I run the loop with the unremed cylinder concurrently with the "dishcutout" cylinder, which if you notice is an exact copy with the exception of the pigment statement, of the "dishcutout" cylinder definition, I get the six correctly placed and oriented cylinders. 

Is there some kind of limitation in the difference statement that would preclude using the loop function for making multiple CSG subtractions? 

I seem to remember someone who made gears by CSG subraction. I believe it was an old raytracing contest winner or runner up. It was a rendering of an internally exposed mechanical clock. 

I have done it by defining them individually. I'm just trying to simplify and condense the code.
 

1) With a while loop, everthing between the #while and #end statements is 'executed' each time the loop runs; in your case, not only were you redeclaring X and Y, you were also redeclaring the Dish and DishCutout objects, as well as creating six copies of the final difference object!  Because each copy included only one DishCutout and they all occupied the same space, you were only seeing one of them in the final render. 

2) A common mistake; you were using trigonometric equations to position objects in a circle.  What many people forget is that this is exactly what POV-Ray does with the rotate command, and it's a lot easier to use and understand. 

So here is the (much simpler) code that should do what you want: it declares the necessary variables and object definitions just once, and then starts the difference object.  After invoking the base Dish object, the while loop is used to place 6 copies of the Cutout object, using simple translations and rotations to move them into position.  Then the while loop is finished, the object is textured, and there you have one copy of your desired object (of course, you could add a '#declare MyDish=' statement before the difference and then reuse the object in mulitple positions, if you wanted). 

// -- START POV CODE -------------------- 

#declare Radius = 2 
#declare CutoutCount = 6     // Actual number of desired 
#declare CutoutOffset = 30   // Measured in degrees 
#declare Dish = cylinder {<0,0,-.25>, <0,0,.25>, 3} 
#declare Cutout = cylinder {<0,0,-.3>, <0,0,.3>, .65} 

difference { 
   object {Dish} 
   #declare Count = 0 
   #while (Count < 1) 
      object {Cutout 
        translate x*Radius 
        rotate z*CutoutOffset 
        rotate z*Count*360} 
   #declare Count = Count + 1/CutoutCount 
   #end 
   texture {Brushed_Aluminum}} 

// -- FINISH POV CODE ---------------------