I wish Android would do some equivalent of iOS's multipeer and bundle all their direct device-to-device technologies under one comms layer agnostic API. I don't really want to have to write code to support bluetooth, WiFi Direct and WiFi Aware (new for Android O - https://developer.android.com/preview/features/wifi-aware.html) just for some 1 vs 1 multiplayer to accomodate a minority of users who want to play when there's no router around.

0.5/0.1/0.1 is a dark shade of red. This is what it looks like.
If you view the screenshot in an image editor you'll see that they have RGB 121/23/22 which is (mostly) correct (allowing for rounding and FP imprecision).
Is this a single-buffered GL context?
Doh - I misread it as RGBA .5f 1f 1f 1.0f somehow!

Agree that this is your only option. Another thing to bear in mind is that if you have a desync bug in your client code that only affects certain clients (e.g. maybe it affects users with certain hardware, or users with certain options set) then you're in real danger of flagging them as a cheat (a false positive) so you must be careful in your punishment strategy.
In terms of spotting the specific cheat you've identified, I don't really know, but if you're on Steam, then perhaps Valve-anti-cheat could help. If you block this one particular cheat implementation, then another will pop up in its place.

I've also seen a big drop in downloads from China starting from about the same date. Was bouncing from around 50 to 100 downloads per day in China, just dropped to 10-30 from April 4th.
That said, March seems to have been a good month for us in China, and we've only really dropped to pre-March levels, so my data isn't very conclusive.
I have decided I'm not going to bother chasing Chinese approval.

Using a copy from a VkBuffer instead of from a linear texture is definitely the right track. Trying to use a linear texture for staging is an exercise in frustration because you run into the irritating limitations that apply to linear textures (like limited format/mipmap support).
You shouldn't have to worry about implementation specifics though. Section 18.4 contains pseudocode describing how it expects your texture data to be laid out in your VkBuffer prior to a call to vkCmdCopyBufferToImage.
Assuming you're not using a block compressed format, the spec says:
rowLength = region->bufferRowLength;
if (rowLength == 0)
rowLength = region->imageExtent.width;
imageHeight = region->bufferImageHeight;
if (imageHeight == 0)
imageHeight = region->imageExtent.height;
elementSize = <element size of the format of the src/dstImage>;
address of (x,y,z) = region->bufferOffset + (((z * imageHeight) + y) * rowLength + x) * elementSize;
where x,y,z range from (0,0,0) to region->imageExtent.{width,height,depth}.
There is no need to worry about implementation specifics for staging texture data, that's the driver's problem/responsibility.

It isn't clear from the OP why you don't plan to go to university, but if you wanted to get a degree, I reckon you'd be able to get onto plenty of computer science or games programming courses on the strength of those A-level results (although to get into better universities, you might need to retake that math A level). I'm not saying you should get a degree, or that you have to, but just saying that if you think your A-level results have excluded you from that path, then I don't think it's the case.

The big UK conference is Develop in Brighton: http://www.developconference.com/passes-and-prices
University of Essex have something called The Games Hub. This is a slightly old news story but has contact details for the guy who runs things there (top bloke) and you can find out what it's all about: https://www.essex.ac.uk/news/event.aspx?e_id=10916 Depending on your level of experience, you might be able to get some guidance, or give out guidance to enthusiastic students.

Yes. Although I think it's rare that VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT is the best option for synchonisation commands. If your sync primitive is waiting on a previous render to texture which you'll read in a fragment shader, then VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT is overkill, it's only the fragment shader that needs to wait - so your dstStageMask might be VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT.
Or if you're waiting for a vertex shader to finish reading from a texture before you scribble over the top of it, then srcStageMask might be VK_PIPELINE_STAGE_VERTEX_SHADER_BIT.

Interesting question.
I believe it corresponds to the VK_PIPELINE_STAGE_* enums. In this case, if you wanted to use a synchronisation primitive like vkCmdPipelineBarrier to wait on completion of vkCmdClearDepthStencilImage, you need to use VK_PIPELINE_STAGE_TRANSFER_BIT.
Edit: So a less abbreviated version of the 'pipeline' heading would be 'pipeline stage in which this command is executed'

DrMemory might be a decent alternative to valgrind to avoid the need to run on a linux VM.
You might also find memory issues by using _CrtCheckMemory or _CRTDBG_CHECK_ALWAYS_DF: See https://msdn.microsoft.com/en-us/library/974tc9t1.aspx

Yeah - I suspect that too. I wouldn't be surprised if the management of the CPU/GPU clock speed is dynamic enough that launching a new program or alt-tabbing out could lead to a temporary speed recovery.