I googled connecting multiple Arduinos together & most websites recommended using I2C. I didn't completely understand one website's comment about using the Rx & Tx pins. Something about the Rx & Tx pins are used by the UART which is used by the USB. So, does that mean that the Arduinos cannot be daisy-chained together using the Rx & Tx pins?
You can - but not in the naive manner; if you want to do this - look into "microcontroller serial bus" implementations - for example (slow - but works for the purpose the author designed it for):
You could also instead use software serial to define 2 seperate serial ports (2 pins needed for each port) - designate one "in" and the other "out" - and use a protocol to look at the data to know whether to shuffle it forward, or use it at the node indicated (via an address setting).
I also read about I2C using 7-bit & 10-bit addresses. Do the Arduinos use both the 7-bit & the 10-bit addresses? What's the maximum speed of the I2C?
You'll need to look into whatever library allows for I2C interface usage.
None of the websites that I went to recommended using SPI. I know that the hardware for I2C is simpler than SPI, but it is slower than SPI.
I would keep looking - the information is definitely out there.
That said - note that I2C and SPI are only intended for very limited distances - if you want greater distances, you'll need to use a different serial approach (RS-422 or RS-485 for instance) - or a different communications platform (fiber, wifi, ethernet, rf, etc).
How does each slave get its address? Is it hardwired into it or is it assigned to each slave by software?
Usually it is done via software. You can hard code this into each controller - or you can be more intelligent about it: Have all nodes listen for an "address request" - when they hear it (from the master) - have each wait a random amount of time. When a node's time has expired - it checks to see if it already has an address - if it doesn't, it picks a random address, then sends it to the master. The master records it, and then sends back an acknowledgement to the node - the node then notes that it has an address.
If a collision occurs (on the random chance that two nodes communicate to the master at the same time, or other reasons to prevent things from working) - the acknowledgement never comes back to the node. The master continues to send a request for addresses until it knows all nodes have notified it (or you can come up with some other logic).
This is just a brief overview of how to do things (and I am certain that I have missed or goofed on the logic somewhere) - but you can see how you could implement things so that neither the master nor the nodes have to know anything about each other - just try to think of it as if you were blind and in a room with other people (who are also blind) - how would you determine how many of you there are (especially if you are shouting over each other - ie collisions)? That same discovery logic can be applied for a serial network.
What is the external interrupt pin used for?
Interrupts are used to tell a processor that "something has occurred - take care of it now" - when such an interrupt occurs, the processor stops what it is doing (making note of where it was) - executes a special routine (called an "interrupt service routine" - or ISR) - which MUST be very short and very fast (don't dilly-dally in the routine!) - this routine does something for the interrupt (generally sets a flag or increments/decrements a counter or takes a reading or similar - short-n-sweet!) - then the processing continues immediately from where it left off. All of this happens in micro-seconds - very quickly. Note that while it is in the ISR - the processor can't service other interrupts should they occur (actually - that all depends on the architecture and how the interrupts are defined).