Does object instantiation have to occur inside using block expression?

In the second example, the object will not be disposed correctly if an exception occurs after File.Create but before the corresponding using statement. In this code, an obvious possibility would be File.OpenRead throwing an exception because "input.txt" wasn't found.

Guaranteeing that the Dispose method is called even if exceptions occur is the biggest advantage of a using statement over simply calling Dispose() at the end of the method. Separating the object creation from the using block has a high chance of breaking that guarantee.

Additionally, as others have noted, instantiating the disposable object inside the using statement as in the first example limits the variable scope so that the object can't be accessed after being disposed. It's also simply shorter and cleaner, at least in these examples.

This:

using (Stream stream_dst = File.Create("output.txt"))
using (Stream stream_src = File.OpenRead("input.txt"))
{
    stream_src.CopyTo(stream_dst);
}

is the same as this:

using (Stream stream_dst = File.Create("output.txt"))
{
    using (Stream stream_src = File.OpenRead("input.txt"))
    {
        stream_src.CopyTo(stream_dst);
    }
}

Both ensure that if an object is created it will also get disposed.

In this case:

Stream stream_output = File.Create("output.txt");
Stream stream_input  = File.OpenRead("input.txt");

using (Stream stream_dst = stream_output)
using (Stream stream_src = stream_input)
{
    stream_src.CopyTo(stream_dst);
}

stream_output will get disposed because you're disposing stream_dst, and it's the same stream. But if an exception is thrown before that using block then stream_output will not get disposed.

A using block allows us to combine creating/acquiring an object with ensuring its disposal. If the using block follows creating/acquiring the object then it will still dispose it, but only if no exception is thrown before the using statement is executed. We wouldn't generally separate the two because combining them is the benefit of using.

Technically they are different however it is minor.

The point of a using statement is to ensure disposal of managed types that access un-managed resources.

STYLE 1:

Declaring and initializing within a using statement (block) ensures that .Dispose() is called on the IDisposable objects declared and initialized within it. Even if an exception occurs. This approach prevents access to these objects from outside the scope of the using block.

// *** Declaration and Instantiation within using statement ***
// *** prevents access to these variables outside of the scope ***
// *** of the using statement. ***
using (Stream stream_dst = File.Create("output.txt"))
    using (Stream stream_src = File.OpenRead("input.txt"))
    {
        stream_src.CopyTo(stream_dst);
    }

STYLE 2:

Declaring and initializing outside of a using statement (block) and them declaring and initializing objects based on them inside of a using block will still allow the initial objects to be disposed of properly, however if an exception were to occur before the using block the objects will not be disposed of by the using block. It also allows you to reference the potentially disposed objects after you have used them in the using block, which could cause you headaches in the future. If that happens you'll probably see an exception message relating to accessing a disposed closure.

Stream stream_output = File.Create("output.txt");
Stream stream_input  = File.OpenRead("input.txt");

using (Stream stream_dst = stream_output)
    using (Stream stream_src = stream_input)
    {
        stream_src.CopyTo(stream_dst);
    }

From the microsoft docs about using style 2:

You can instantiate the resource object and then pass the variable to the using statement, but this is not a best practice. In this case, after control leaves the using block, the object remains in scope but probably has no access to its unmanaged resources. In other words, it's not fully initialized anymore. If you try to use the object outside the using block, you risk causing an exception to be thrown. For this reason, it's generally better to instantiate the object in the using statement and limit its scope to the using block.

Interesting to note:

According to the docs you can declare multiple instances of a type in a using statement. What I take from this is you should be able to do the using statement declaration like so:

using (Stream stream_dst = File.Create("output.txt"), Stream stream_src = File.OpenRead("input.txt"))
{
    stream_src.CopyTo(stream_dst);
}