Does its data get sent to GPU memory only once and sit there forever?
Usually yes, but the driver is free to do what is "optimal", the data might be stored at VRAM or RAM or could just be cached here is an atricle that explains what actually happens with the VBO floatflow.
For example if it was flagged as a dynamic openGL buffer (e.g. VBO), it's more likely to be stored in RAM. GPU use direct memory access (DMA) to access the ram directly without the CPU intervention, this is controlled by the DMA controller in the graphics card and graphics driver and is executed in kernel mode.
When the model gets actually rendered each frame do GPU processors have to fetch its data each time from GPU memory, even if a model is rendering multiple sequential times ?
Just like CPUs, GPUs are permitted to re-order GPU instructions and memory access operations, (read: out of order execution) so most likely the GPU will handle the scenario you mentioned by accessing the memory that is in it's cache (usually accessed recently), but sometimes it can't do this.
Obviously graphics cards have limited RAM - when it can't hold all the model data necessary for rendering 1 frame I guess it keeps fetching (some of) it from CPU RAM each frame, is that correct?
You don't want this to happen. But regardless if that happens the GPU will start moving memory between RAM and VRAM (the command processor on the GPU is responsible for this) which will make rendering much slower which will case the GPU to stall, because it will need to wait for the data to be copied from/to V/RAM.
There's sending the data to the GPU and there's setting/binding the buffers as current. Does the latter cause any data flow?
GPUs contain a command buffer, and all API commands are submited to this buffer, notice that this can happen simultaneously with the data being copied to the GPU. The command ring buffer is a communication queue between the CPU and GPU, any command that needs to be executed needs to be submitted to the queue so it can be execulated by the GPU. Just like any operation binding new buffers needs to be submitted to the gpu so it can access some memory location.
That's one of the reasons glBegin/glEnd was deprecated, submitting new commands needs queue synchronization (using memory fences/barriers).
As for your other points:
Buffer creation with initialization
You can allocate a buffer without initialization and keep it for later use. Or you can allocate it a buffer and copy data at the same time (talking about the API level).
buffer data update
You can use glMapBuffer to update memory on the GPU side. whether the memory will be copied from/to RAM is not actually poart of the standard and will vary greatly depending on the Vendor, GPU type and driver.
API draw call (here I'd like to hear from you what actually happens there).
My second point in the main question covers this.
binding the buffer as active (is it just a way to tell the API that I want this buffer to >be rendered in the next draw call and it doesn't do anything by itself?)
Think of binding as using this pointer in any object oriented language, although not strictly the same, any consequent API calls will be relative to that bind buffer.