* Check instance defintions for mediums

* Replace structured binding with a traditional iterator

This keeps the loop consistent with the rest of the code base and avoids
creating an unused variable.

(Rather than just printing a warning.) Issue #152.

Just variable renaming and formatting...

The Camera, Filter, Film, and Sampler are all created using RunAsync() calls as
soon as their specifications are available. This also cleans things up from the
caller side as we take care of the dependencies between them (e.g. the Sampler
needing the Film resolution) once inside BasicScene.

Rather, check the actual objects used for rendering. (This will allow making more
members of ParsedScene private...)

SceneStateManager -> BasicSceneBuilder
Add various object creation methods to BasicScene
Remove redundant threadAllocators parameter from BasicScene::CreateMaterials()

Remove SceneProcessor interface class (only had one implementation)
Rename ParsedScene -> BasicScene

s/T_hat/beta/g
s/uniPathPDF/inv_w_u/g
s/lightPathPDF/inv_w_l/g

In preparation for changes corresponding to a02c2d0c. Note that
the variable names do not match their actual usage, but this makes the forthcoming
actual logic changes easier to review.
logic changes

Issue #170.

This gets rid of a bunch of unnecessarily duplicated code...
(And removes a long-obsolete assumption that all area lights are
DiffuseAreaLights.)

The previous implementation repeatedly assumed that Allocators were
thread safe; this is not required for std::pmr allocators, but happened to
be the case when the default allocator is used on the CPU (since new/delete
are thread safe.) For the GPU, the CUDATrackedMemoryResource was
also thread-safe, but it also included some per-thread caching that doesn't
really belong in a memory resource.

Therefore, the WavefrontPathIntegrator (and friends) now no longer assume
that allocators are thread-safe, but instead explicitly use per-thread allocators
in parallel code. CUDATrackedMemoryResource is simplified to be just a
memory resource, and now we use a std::pmr::monotonic_buffer_resource
when we actually want chunked allocation.

Fixes #150.

(Which seems to be a strange MSVC + CUDA 11.1 interaction...)

Also, add a check that issues an error if there is a MixMaterial that uses
a complex texture to select between the materials (which isn't supported in
the current implementation).

This way, we can not increment the ray depth when it passes through a
surface that markes the boundary between different media, matching the
behavior of the regular CPU path.

In particular, this fixes some undesirable noise in the wavefront
integrator (and different behavior from the regular CPU path) that was due
to the ray depth being incorrectly tracked in scenes with participating
media and then Russian roulette inadvertently being applied after the very
first surface intersection.