Inconsistensies with the Compute Shader tutorial

I've been trying to follow along with the compute shader tutorial after doing everything up till this tutorial, and it seems like the compute shader section is based off an older version of the tutorial, as there are multiple inconsistencies with how the code is structured. These are a couple of the issues I've found:

In [Drawing a Triangle / Setup / Logical device and queues](https://docs.vulkan.org/tutorial/latest/03_Drawing_a_triangle/00_Setup/04_Logical_device_and_queues.html#_retrieving_queue_handles), the graphics queue is created like so:

```cpp
graphicsQueue = vk::raii::Queue(device, graphicsIndex, 0);
```

In the compute shader section, the compute queue is created like so:

```cpp
computeQueue = std::make_unique( *device, graphicsAndComputeIndex, 0 );
```

The "[Loading compute shaders](https://docs.vulkan.org/tutorial/latest/11_Compute_Shader.html#_loading_compute_shaders)" section states to load in the shader with

```cpp
vk::PipelineShaderStageCreateInfo computeShaderStageInfo({}, vk::ShaderStageFlagBits::eCompute, shaderModule, "compMain");
```

but this gives errors with constructor parameter mismatches. Seems like the fix is to create the computer shader stage in the same way the vertex/fragment shader stages are created in the other tutorial section:

```cpp
vk::PipelineShaderStageCreateInfo computeShaderStageInfo {
.stage = vk::ShaderStageFlagBits::eCompute,
.module = shaderModule,
.pName = "compMain"
};
```

When dispatching work, the tutorial says

> Now it’s time to actually tell the GPU to do some compute. This is done by calling computeCommandBuffers[frameIndex]→dispatch inside a command buffer. While not perfectly true, a dispatch is for compute as a draw call like commandBuffers[frameIndex]→draw is for graphics. This dispatches a given number of compute work items in at max. three dimensions.

yet `commandBuffers[frameIndex]→draw` isn't used before in the tutorial. There are a few others (e.g the `createBuffer` function having a different prototype than the one in earlier sections, the `std::array layoutBindings` also needing to be created with structs, instead of `vk::DescriptorSetLayoutBinding`, etc.)

The computer shader tutorial also assume a lot more than the previous sections. When creating the compute queue, it assigns to a `computeQueue` variable that hasn't appeared anywhere before up till this point. A few sections later, in the loop where the particle positions are initialized, it creates `std::vector particles(PARTICLE_COUNT);`. This is the first time `PARTICLE_COUNT` is mentioned, and the first time the C++ Particle struct is mentioned. Neither are defined or mentioned anywhere after (though the Particle struct is added onto later).

Compare the Compute Shader tutorial with the referenced Drawing a Triangle sections, especially Logical device and queues and Loading compute shaders. Review the queue, shader-stage, dispatch, createBuffer, descriptor-binding, and particle examples for consistency and missing definitions. Done means the compute tutorial follows the current API style and introduces every required symbol before use.

Written by the indexing model from the issue text.