This will most certainly add delays as you are polling the pin in a blocking loop
while (digitalRead(RCpin) == LOW) { // count how long it takes to rise up to HIGH
reading++; // increment to keep track of time
if (reading == 30000) {
// if we got this far, the resistance is so high
// its likely that nothing is connected!
break; // leave the loop
}
Assuming that your compiler can optimize the code extremely efficiently this loop would take something like 4 lines of code to execute since you have to read the pin, then compare it to a value, then branch based on the outcome (I would be very impressed if you could get this few instructions). Further assume that each one of those instructions takes only 1 clock cycle to execute (this is also probably going to take more, but it helps to bound the problem). This routine could take at most:
\$MaxRoutineTime = LoopIterations \times \frac{Instructions}{LoopIteration} \times \frac{Seconds}{Instructions}\$
\$MaxRoutineTime = 30,000 \space Iterations\times \frac{4 \space Instructions}
{LoopIteration} \times \frac{Seconds}{8,000,000 \space Instructions}\$
\$MaxRoutineTime = 15 \space mS\$
but I assume it will take a little more than that because of the aforementioned allowances.
The reason it does not add delays when using an ADC is because the peripheral can be setup to generate interrupts and you will only be notified when the ADC reading is complete. The time it takes the ADC to complete a measurement is a finite number of clock cycles, so the app note you're referencing is pointing out that if you slow your clock speed, though the ADC will still take the same number of clock cycles to complete a measurement, your measurement will take longer because the clock is slower.
Edit
At first glance from your picture, combined with the fact that you mentioned audio, I thought you were measuring a microphone input. However, it appears that you're just using a Force Sensitive Resistor (FSR) which is just a pressure sensor. If you don't need to know the amount of pressure, only that it was pushed, you don't have to go through all the trouble of finding the exact reading. You can simply use any interrupt-generating, digital input if you pick the correct resistor value (in place of the capacitor). You will simply set a digital pin to generate interrupts on rising edges and pick a resistor that will give you a state change (low/high) with the desired amount of force for your touch. Then you'll know each time the FSR was pushed and can handle it in an un-blocking fashioner, introducing the least latency possible.
The analog pins on an Xbee act virtually identically to the analog pins on an Arduino -- they are inputs to a successive approximation analog-to-digital converter. If the ADC performance of the Xbee is sufficient for your application, then you don't need an additional microcontroller (check the Xbee datasheet for this). And yes, you should use a half-wave rectifier or some other means of protecting your input pins, since the current sensor you mention can output negative voltage.
Best Answer
You need to amplify your -1 to +1V signal to 0-10V, so a gain of 5 is required (with a input shift of +1V for single rail)
An opamp set up in non-inverting mode is a simple and accurate way of doing this. YOu also need to shift the +1V to -1V AC waveform so it's all positive (if you are using a single rail supply) Here is a circuit similar to the one you linked to, but setup for 10V output. L1 and L2 represent the transformer, V2 supplies 30A at 100V for simulation. R5 is included in your CT, so all you need is R1, R4 and everything to the right of them:
Simulation - here are the waveforms, you can see the 30A input, the 1VAC output (shifted to 0V-2V by the 1V output from the R1 and R4 divider) and the opamp output from 0-10V.
The opamp can be any rail to rail input and output part (unless you are using dual rail) with a supply range of over 10V (Opamp positive supply needs to be >+10V)