Compilers generally work in a few phases.
First they have to parse the language (which itself may be broken into tokenization and grammar rule matching; C/C++ also have a preprocessor step that has its own tokenization and grammar) followed then by a correctness analysis pass (which may be partially or fully combined with the parsing pass).
After that, compilers will usually have some kind of high-level representation of the source code. This is then converted into an intermediate representation that is easier to perform optimization passes over. Once optimizations are done, the compiler will produce executable code in the target architecture's correct format. Some compilers have extra steps in there, or jumble the steps together a bit, but that's the gist of it.
LLVM handles that second part. It is a library that handles data in a specific intermediate representation (aka IR), implements a number of high-power optimization passes over that representation, and then includes "backends" which generate code for a specific machine.
Clang is a project bundled with LLVM that parses C, C++, Objective-C, and OpenCL kernels and generates LLVM IR. It then lets LLVM do optimizations and produce machine code.
The backend doesn't have to produce actual binary code for a machine. It can be binary code for a virtual machine (such as JVM bytecode or CLR/.NET bytecode). It can also be a text format, such as assembly language or the text encoding of LLVM IR itself, or even an entirely different language. Essentially, the backend converts the IR into some other format.
Emscripten is a project that mostly revolves around adding a LLVM backend that generates JavaScript (specifically the asm.js subset of it) from the LLVM IR. This means that any code that can be represented in LLVM IR (whether it comes from Clang or somewhere else) can be converted into asm.js using Emscripten's backend.
Converting one language into another language is often called "transpiling" these days. One does not _need_ something like LLVM to do this, but given the vast differences in the computing model of C and JavaScript, it really helps to have a good optimizer simplify the input C++ code to simpler machine-like instructions that can be translated to the target language.
Emscripten also provides implementations of various C libraries that wrap the JavaScript environment. That is a slightly more complex topic that requires you to understand linkers and how the full C/C++ compilation model works, and I'm not sure that's the case.
The result is that C code like
int a = func(b * 2); int c = a - 1;
gets translated into LLVM IR like
$0 = %b * 2; %a = call func $0; %c = %a - 1;
and then the Emscripten backend translates that into JS like
var _0 = (b * 2)|0; var _1 = func(_0)|0; var c = (_1 - 1)|0;
The final bit is the form described by asm.js, which is legal JavaScript but with some extra hints to help specialized JIT engines generate faster machine code.
The JS is just JS. You load it into a browser just like any other JS. It can be interpreted by any JavaScript engine, though it'll probably be very slow on any browser that doesn't explicitly optimize for asm.js formatted code. Emscripten is just converting C++ source into JavaScript source.
Note the "oddness" of the generates JS. Emscripten does not convert C++ classes into JavaScript objects, among many other things. This is because JavaScript objects work nothing at all like C++ classes, and also because JS objects can be horribly inefficient (they're by-reference heap-allocated bags of arbitrary key-value pairs). There are features in JS like typed memory arrays that can simulate the unofficial memory model of C++, and C++ pointers can then just be treated like integers into an array of bytes. There are similar tricks for dealing with integers, which don't exist in JavaScript.
The asm.js is so named because it only really supports simple operations on integer-like constructions and typed arrays, much like assembly language only really supports simple operations on registers and memory. It's not a special byte code, just a valid subset of JavaScript that is capable of emulating the C++ environment and which is easy for specialized JavaScript JIT engines to optimize into actual machine code.
Projects like WebAssembly seek to provide an actual binary "machine code" for the Internet to get around the size and speed limitations of using JavaScript for distributing and executing compiled languages like C++ or C#.
Short version: Clang parses C++ source and generates LLVM IR. LLVM+FastCode converts LLVM IR into JavaScript source. Finally, Emscripten glue emulates common C libraries in the JavaScript+browser environment.
