Can smart contracts deploy other smart contracts? If a smart contract has the compiled bytecode for a contract can the first deploy a subsequent contract?
According to Ethereum.org:
"To deploy a smart contract, you merely send an Ethereum transaction containing the compiled code of the smart contract without specifying any recipient."
I looked for how to send a transaction via smart contracts and the closest I could find were examples for transferring ETH...
    _to.transfer(msg.value);
  
    bool sent = _to.send(msg.value);
   
    (bool sent, bytes memory data) = _to.call{value: msg.value}("");
   


to make a smart contract deploy another smart contract you can do it with the use of the new keyword
contract UserMessage {
  string message;
  constructor(string memory message){
     message = _message;
  }
}

contract DeployUserMessage {
  mapping(address => address) userToContract;
  
  function Deploy(string memory message) public {
    address contractAddress = new UserMessage(message);
    userToContract[msg.sender] = contractAddress;
  }
}

I think this example make it clear, but if you want, check the docs https://docs.soliditylang.org/en/v0.8.9/contracts.html#creating-contracts

Yes It can, and it's called Factory Pattern contracts
contract Child {
    string public name;
    string public gender;

    constructor(string memory _name, string memory _gender) {
name = _name;
gender = _gender;
    }
}

contract Parent {

    Child public childContract; 

    function createChild(string memory _name, string memory _gender) public returns(Child) {
       childContract = new Child(_name, _gender); // creating new contract inside another parent contract
       return childContract;
    }
}


New Keyword is used to create contract in another contract function.

If it is a payable contract then :
contract Child {
    string public name;
    string public gender;

    constructor(string memory _name, string memory _gender) payable {
name = _name;
gender = _gender;
    }
}

contract Parent{

    Child public childContract; 

    function createChild(string memory _name, string memory _gender) public payable returns(Child) {
require(msg.value == 0.005 ether)
       childContract = new Child{value: msg.value}(_name, _gender); // creating new contract inside another parent contract
       return childContract;
    }
}


Another way is to call the parent's constructor if you are inheriting. For example, let's say you have "Name" contract
contract Name {
    string public name;

    constructor(string memory _name) {
name = _name;
    }
}

Now my base contract should inherit from "Name" contract
// I deployed a new Name contract
contract Base is Name("Ronaldo"){}