I strongly recommend adopting an existing Instruction Set Architecture (ISA), unless you are very keen to write your own C compiler. A related issue is, should your machine be 'self hosting'? Do you want the machine to be able to run the compiler, and compile programs, including the OS on itself. The implications of that decision constrain several choices.
Another issue is what you want from the "POSIX OS". POSIX was a specification derived from UNIX. You could run a 'real' UNIX variant. Sources are stored at The Unix Heritage Society.
If 'self hosting' is a requirement, then probably your only 16bit CPU choice is PDP-11, and use UNIX Edition 6, Edition 7, or early BSD's. See What Unixes run on What PDPs?. It'll be hard to cram a modern UNIX-like system onto anything that small.
I think a PDP-11 could be implemented in 'TTL'. However, it did have quite a complex instruction set (with lots of addressing modes, and multi-length instructions). The upside is you would have a compiler, working UNIX, and likely a bunch of people who might be interested in collaborating.
To reduce the number of chips, designs used 'bit-slicing'. Typically this implemented 4-bit-wide 'slices' through a CPU and could be 'cascaded' side by side to make any width machine in multiples of 4 bits. Those machines were typically driven by microcode, which coordinated each step within each instruction. Microcode could be changed, so it could have almost any instruction set desired. If the microcode store was RAM it could change its instruction set on the fly!
One popular bit-slice family was AMD's 2900 bit slice. A lot of machines were built using it, including a few 32bit (IIRC). I've had a quick search, and I can't find anyone making that any more.
However, it looks like TI's 74181 are available. It's a 4-bit wide bit-slice ALU. It was used in many significant machines of the '70's, e.g. the Xerox Alto.
Moving up to 32bit gives a lot more options. People did build commercial 32bit machines from discrete logic in the 80's, sometimes using bit-slice, but they were quite complex.
By choosing an existing Instruction Set Architecture (ISA), you might get a portable compiler, and a version of xBSD, Linux, OpenSolaris, etc. which satisfies your POSIX needs.
Avoid heavily-protected Intellectual Property or complex instruction sets. Rather than Intel, ARM, or IBM, you could choose an existing RISC ISA. With RISC there's a good chance of understanding the design, and getting it to work.
Use an existing FPGA development board to get started, and quickly make progress; you could have a machine up and working quickly with no electronics to build or debug. You might still choose to build custom hardware, once the FPGA has proven everything. You might even migrate the FPGA to discrete logic in pieces, an option earlier designers did not have.
There are many choices of 32bit Architecture that support a POSIX OS. If you only used Xilinx FPGAs, there is MicroBlaze. That has a lot of flexibility in its implementation, and also has both GNU tool support, for the compiler tool chain, and Linux support.
Aim to implement an existing 'RISC' architecture which is explicitly Open Source, and which has an active community who might be interested in helping.
They all have FPGA implementations.
OpenSPARC has many POSIX operating systems. OpenRISC seems to have a lot of related Harware IP which might help
RISC-V is bidding to be come the Open Source Instruction Set Architecture (ISA). It involves people who had worked on the Berkely RISC, which led to the SPARC. RISC-V is much more similar to MIPS, and claims some of the weaker decisions are improved.
The Case For RISC-V