Is Thread.Sleep(Timeout.Infinite); more efficient than while(true){}?

I would recommend using a ManualResetEvent (or other WaitHandle), and calling ManualResetEvent.WaitOne.

This will have a similar effect to sleeping forever, except that it provides you a clean way to exit from your infinite "block" when desired (by calling Set() on the event).

Using while(true) will consume CPU cycles, so it's definitely something to avoid.

is there anything that I should not be doing, such as modifying a static collection declared in the scope of the class?

In general, no. Since your thread will be blocked, there shouldn't be any synchronization issues with using shared data (provided the items within the collection don't have specific requirements, such as user interface elements which must be used on a thread with a proper synchronization context.)

Since C# 7.1, you can make the Main method asynchronous. That means instead of using busy-wait or thread-locking sleeping, you can suspend the Main method asynchronously as a Task. This way, the thread which ran Main will not be locked. And with Cts.Cancel(), you can easily release the main task to exit the application (without allowing work for other threads/tasks to finish).

static readonly CancellationTokenSource Cts = new CancellationTokenSource();
static async Task Main(string[] args)
{
    /* your code here */

    // Task running Main is efficiently suspended (no CPU use) forever until Cts activated with Program.Cts.Cancel(); (thread-safe) from anywhere.
    await Task.Delay(Timeout.Infinite, Cts.Token).ConfigureAwait(false);
}

Since year 2020, C# 9.0, the whole Program.cs file content can literally look exactly like this:

using System.Threading;
using System.Threading.Tasks;

CancellationTokenSource Cts = new();

/* your code here */

// Task running Main is efficiently suspended (no CPU use) forever until
// Cts activated with Program.Cts.Cancel(); (thread-safe) from anywhere.
await Task.Delay(Timeout.Infinite, Cts.Token).ConfigureAwait(false);

You can try-catch TaskCanceledException if infinite-sleep cancellation is normal codeflow for the case (please DON'T use Task.Delay inf-sleep then you are trying to await/sync with other Tasks, try-catch is less efficient and will confuse teammates):

try
{
    await Task.Delay(Timeout.Infinite, Cts.Token).ConfigureAwait(false);
}
catch(TaskCanceledException) { /* Ignored */ }

I think the call

while (true) { ... } 

is computationally intensive, since the thread never stops, wheareas

Thread.Sleep(Timeout.Infinite);

actually gets the thread to sleep with help of OS native schedulers. And then the thread actually stops, so I suppose it's less computationally demanding.