Need to call yield TWICE ??? (ANSWERED)

I tested this script, and it performed the same with one or two yield (at least in my PC notebook).
Anyway, if you don't want to stop Unity while a long routine executes, you must place yield instructions at well chosen places. Simple yield instructions like those in your code just stop coroutine execution and return to the calling routine - but an internal control structure remains active, and in the next update cycle the coroutine is automatically resumed in the instruction after the yield (that's why @dannyskim was talking about frames).
If you must call some slow function 10000 times at some point of your game, for instance, and want to span the loop over several frames, you can use this:

 for (var i = 0; i < 10000; i++){
   SlowFunction(i);
   yield; // let Unity free until next frame
 }

But since each yield releases Unity up to the next frame, this will take 10000 frames to execute! You should thus find a good compromise - maybe yield at each 100 iterations:

 var n = 0; 
 for (var i = 0; i < 10000; i++){
   SlowFunction(i);
   if (++n == 100){ // reached 100?
     n = 0;
     yield; // let Unity do other jobs until next frame
   }
 }

Since this is a coroutine, control will return to the caller code immediately (or in the first yield, I'm not sure), but it will keep running behind the scenes, thus you can do anything you want while the long routine executes.
NOTE: Yield cannot be used in all routines! The docs mention Update and FixedUpdate, but other periodic functions like LateUpdate and OnGUI can't be coroutines as well. Another limitation: a coroutine can't return anything (it actually returns IEnumerator, thus no other value can be returned).

EDITED: I tested the script again with several combinations of yields, and it produced weird and unexpected results for each combination. I also tested it in a C# version, but the results were the same. It's really frustating: you just can't predict what the hell it will do in each case!
But the problem is actually caused by the sync between the console and the update cycles: Unity performs as expected, resuming after the yield instruction in the next frame, but the console is updated at weird intervals.
The script below shows the actual time and frame count, but the first two lines appear at the same time, while the others seem to appear at the right intervals:

function Update(){ if (Input.GetButtonDown("Fire1")){ runMeOneChunkAtATime(); } }

var startTime: float; var startFrame: int;

function PrintTime(id: String){ print(id+" T= "+(Time.realtimeSinceStartup-startTime).ToString("F3")+" F= "+(Time.frameCount-startFrame)); }

function runMeOneChunkAtATime(){

 var r:float;
 var x:int;
 
 startTime = Time.realtimeSinceStartup;
 startFrame = Time.frameCount;
 
 for(x=0;x<100000000;++x) r += Mathf.Sqrt(x+r);
 PrintTime("aaa");
 yield;

 for(x=0;x<100000000;++x) r += Mathf.Sqrt(x+r);
 PrintTime("bbb");
 yield;

 for(x=0;x<100000000;++x) r += Mathf.Sqrt(x+r);
 PrintTime("ccc");
 yield;

 for(x=0;x<100000000;++x) r += Mathf.Sqrt(x+r);
 PrintTime("ddd");

} The values updated at the right times when a GUIText was used instead of print.
NOTE: I finally found the answer to my own question: the coroutine returns control to the caller when the first yield is executed, not immediately.