The PowerShell scopes article (about_Scopes) is nice, but too verbose, so this is quotation from my article:

In general, PowerShell scopes are like .NET scopes. They are:

• Global is public
• Script is internal
• Private is private
• Local is current stack level
• Numbered scopes are from 0..N where each step is up to stack level (and 0 is Local)

Here is simple example, which describes usage and effects of scopes:

$test = 'Global Scope'
Function Foo {
    $test = 'Function Scope'
    Write-Host $Global:test                                  # Global Scope
    Write-Host $Local:test                                   # Function Scope
    Write-Host $test                                         # Function Scope
    Write-Host (Get-Variable -Name test -ValueOnly -Scope 0) # Function Scope
    Write-Host (Get-Variable -Name test -ValueOnly -Scope 1) # Global Scope
}
Foo

As you can see, you can use $Global:test like syntax only with named scopes, $0:test will be always $null.

Is there a Scope Preference for Variables like there is for some other settings ($ErrorActionPreference, etc)?

No, scoping behavior is part of the language's core runtime semantics and is not configurable.

I'm working on a script that has a bunch of functions that call on information created in each other and I'm just looking to avoid writing $Script: or $Global: in front of each variable everytime

You don't need it everytime - you only need the scope modifier when you're writing to a parent scope.

Resolution of variables for reading will fall back through parent scopes and eventually the global scope, until a matching variable is found:

# variable defined at script scope, functions defined in here will fall back to resolving this when `$Config` is referenced
$Config = @{
  'setting' = 'initialValue'
}

function Update-Config {
  # Scope modifier is only necessary when "writing up" through the scope stack
  $script:Config = @{
    setting = 'updatedValue'
  }
}

function Do-Stuff {
  $setting = $Config['setting'] # no need to use script: here

  Write-Host "About to do something with '$setting'"
}

Do-Stuff
Update-Config
Do-Stuff

Executing the above in a script file will print:

About to do something with 'initialValue'
About to do something with 'updatedValue'

Note that for functions bound to a module, the script: scope is shared across the module - writing to $script:Variable in one module function will cause resolution of non-local $Variable to resolve correctly in any other function in the same module

For more information about scoped variable resolution, consult the about_Scopes help file

Starting with the latter question:

Scopes come in play with functions and invoked scripts(cmdlets), like:

Function Test {
    $Test++
    Write-Host 'Local:' $Test
}
$Test = 5
Test
Write-Host 'Global:' $Test

Returns:

Local: 6
Global: 5

And:

Function Test {
    $Global:Test++
    Write-Host 'Local:' $Test
}
$Test = 5
Test
Write-Host 'Global:' $Test

Returns:

Local: 6
Global: 6

Or if you put the function in a script (e.g. MyScript.ps1):

$Test = 5
.\MyScript.ps1
Write-Host $Test # $Test is unaffected unless you use the $Global scope in your script

Which will return basically the same results as above, unless you Dot-Source your script where it will run in the current scope:

$Test = 5
. .\MyScript.ps1
Write-Host $Test # $Test might be affected by MyScript.ps1 if you just use $Test

For what you are doing:
You are creating a complete new PowerShell session (with Powershell.exe) which will start with a fresh list of variables.
Note here that you will see the initial variables again if you exit from the new session:

PS C:\> $Name = "John"
PS C:\> Powershell.exe
Windows PowerShell
Copyright (C) Microsoft Corporation. All rights reserved.

Try the new cross-platform PowerShell https://aka.ms/pscore6

PS C:\> Write-Host 'New session' $Name
New session
PS C:\> Exit
PS C:\> Write-Host 'Initial session' $Name
Initial session John

Which regards to the first question, I don't think that there are many applications where you need to explicitly refer to the $Local scope, but to give you an example where you might use it:

$Test = 5
Function Test {
    Write-Host ($Local:Test++)
}
Test

In the above example the unary increment operator will start with 0 if you explicitly use the $Local scope (in fact you starting with an empty local variable which will cast to 0) and with 5 if you omit the $Local scope where you will inherit a copy of the $Test variable out of the parent scope.