Use a Distributed Version Control System like git and use your shared folders machine to store the reference repository. Here's why:
Each clone is a backup
If the server hard drive crashes, everyone has a copy, ready to be deployed on a new drive or server. As your company is not serious about version control, I suppose it may be pretty much the same with backups.
Having a main repository with a master branch allows to know the version that has the last word. This solves the "You have tested your changes against Franck's version, but did you have John's too? And how did you merge them?".
Deliver more comfortably
The customer wants an alpha version today? Well, you can test if master is stable enough and ship that. If it's not and you don't have the time to fix it, just go back in time and get an older but more stable version. You can't do that if you only have the latest version.
Go back in time and fix your mistakes
Your manual merge had issues that you only saw after after a few days, but you already have overwritten the content of your shared folders? Without a VSC you have no history so you can't easily go back to a point where you can check the mistakes you made and fix them. Code is not like a picture, it's like a movie: it evolves in time. You can extract a picture from a movie. You can't extract a movie from a picture.
Locate bugs more easily
A bug appeared but you didn't really noticed at the time it was introduced, so you couldn't fix it while the code was "hot". Now you don't really know which change introduced it, so it could come from several different locations in the code. It will take hours just to find where to look. With git, you could have just developped a test to say if the bug happens on a specific version, and use
git bissect to find the exact commit that introduced the bug. Instead of looking for thousands of lines of code, you now know it's located in that 10 lines change, and you can keep the test in your test suite to make sure the bug is not introduced again.
Each developper is responsible for his/her own work
If you're the team leader, and have no VCS, you'll most probably have to do the dirty work, the merges. If you do it on your own, you probably don't know everything about all the changes and may introduce errors. On the opposite, if you always ask to the people that wrote the code to gather with you each time there's code to merge, then that's time they won't use to produce new code.
With a VCS, in a simple workflow, the developper only has to take care of his/her work, and one external source of changes: the master branch. There may be 1 or 100 people committing in the master branch, that's the same. To be able to push his/her changes, he/she will have to adapt them to the latest changes done by others. It may seem it takes longer to push code, but that's because you're also doing the merge which would have taken time anyway.
The difference is that merge is done by the person that did the changes, who knows that code best because he/she has written it.
Who wrote that code?
There's that bug here, but who has written that particular line of code? It's hard to remember, especially if the project lasts sevral months.
git blame would have told you who and when that line was written, so you can ask the right person, and there's no "I don't remember writing that".
The project is getting bigger
The customer wants more features and you're a team too small, you'll need another developer. How do you manage the increased merge complexity without a VSC?
The customer called and asked for a critical bug fix for the production, but you were currently working on a new feature. Just
git stash to put your changes aside, or commit them in a new branch and push the changes and you're ready to start working on the urgent fix, without fear of losing your pending work.
It worked 10 minutes ago
You're doing some changes locally and something that worked 10 minutes ago stopped working. Without a VCS you either stare at the code or at best, do a copy of the reference version, and diff to see what you changes. Oh wait, the reference changed since I started working, so I can't diff anymore. And I didn't think to keep a pristine copy of the code I based my changes on.
With a VCS, you just do something like
git diff right away, and have your changed compared to the right version of the code you're based on.
I have to keep my debug logs
So you're a bad guy and don't use logging? You had to sprinkle
printfs in all your codebase until you found all those pieces of that nasty bug? Now you found one, fixed it, but want to keep your carefully crafted debugging code to fix remaining issues.
Without a VCS, you either need to copy the files, expurge the debugging code (which may add some editing errors), push that, and put back your backed up files. Oh, but it seems some debugging code got in anyway.
With git, you just
git add --patch and select the few lines of code you want to put in your commit, and can commit only that. Then you resume your work and still have your debugging code. You didn't have to touch the code, so no copy/pasting error.
The big ball of mud
Without a VCS, people work on their side, and give you a bunch of changes, sometimes unrelated. When there's too much code to check, it's hard to find a bug.
A VCS will allow you to do small, incremental changes, and give you a changelog. The changelog is essential: people must tell there why they're doing the change, not what is the change (the what question is alredy answered by the code change itself). This means when you're inspecting some code of a new feature for example, you won't have to read lots of unrelated mixed changes like unrelated bugfixes. This helps focusing on the code you care.
If I give you 100 potatoes 1 by 1, and one is rotten, you will immediately find it. Now if I dump 100 potatoes in front of you and ask you to find the rotten one, that's not the same task.
Hope you have good coding style policy, otherwise indentation changes will get you crazy if you merge by hand. Sure, you can ignore whitespace in the changes (but not in languages when indentation counts, like Python). But then you'll get weird-looking code hard to read.
You're the project leader
If you're the leader, this means you'll get the blame if things don't work. If you can't get comfortable with the situation because your boss still can't understand that using the right tool for the right job is worth it, then at the very least, I'd refuse to become the leader of a predictable failure.